Event publishing API

Bring your events into Pinned Events from the tools you already use

Pinned Events helps people discover local plans through public channels, save events, RSVP, get reminders, and coordinate with friends. Use the API to sync approved event data from your CMS, CRM, forms, spreadsheets, or backend jobs directly into those channels.

Create API key View API reference

Local discovery · Followable channels · RSVP & reminders · Social planning

Pinned Events publishing layer

Turn approved event data into discoverable events.

/api/public/v1

Source systems

CMS

CRM

Forms

Spreadsheets

Backend jobs

Pinned Events API

Validates the request, checks channel access, and publishes the event into the right channel.

Public channelLive

API Launch Workshop

Jun 12, 6:00 PM

New York

Local discoveryPublic channelsRSVPRemindersSocial planning

Discovery and planning layer

What Pinned Events adds to your events

Publishing to Pinned Events is not just another place to store event data. It gives your events a discovery and planning layer people can actually use.

Discovery

People can browse local plans and find events through public channels instead of needing to know your website or calendar already.

Channels

Organizers, venues, and communities can publish into feeds that people choose to follow.

RSVP and reminders

People can save events, RSVP, and get reminders so interesting plans do not disappear after one visit.

Social planning

People can notify friends, see who is interested, and coordinate around events instead of planning in disconnected chats.

External ticketing

Keep your existing ticketing flow while using Pinned Events for discovery, planning, and event visibility.

For teams that publish more events than they want to enter manually

Use the API when Pinned Events is part of your publishing or discovery workflow, but your event data starts somewhere else.

Organizers and promoters

Publish concerts, nightlife, meetups, workshops, classes, launches, or community events into Pinned Events channels.

Venues and local platforms

Keep public event feeds updated from internal scheduling, booking, or content systems.

Community and channel owners

Build useful channels around neighborhoods, interests, scenes, venues, or event categories without entering every event by hand.

Content and operations teams

Turn approved CMS entries, partner submissions, spreadsheet rows, or internal records into draft or published events.

Product and automation teams

Connect your admin panel, marketplace, CRM, no-code workflow, or backend job to the event publishing API.

Publishing breaks when event data lives in too many places

Teams manage events in CMS tools, CRMs, spreadsheets, ticketing systems, partner forms, and internal databases. Without an API, every update becomes another manual publishing step.

Your own website is not always enough

If events only live inside your website, CMS, spreadsheet, or ticketing tool, they depend on people already knowing where to look.

Manual publishing does not scale

Every new workshop, venue update, partner submission, imported event, or recurring session becomes another copy-paste task.

Event details drift across systems

Dates, venues, images, descriptions, and ticket links change. If every system is updated by hand, something eventually becomes outdated.

Automation needs guardrails

Teams want faster publishing, but still need scoped access, channel ownership checks, duplicate-safe retries, rate limits, and audit metadata.

Publish from the systems where your events already start

Use the event publishing API to bring approved event data into Pinned Events without changing the tools your team already relies on.

Explore the API

Publish from CMS content

Send approved events from WordPress, Webflow, Strapi, Sanity, or a custom CMS into Pinned Events channels.

Publish from CRM or back-office records

Create events from records your operations team already manages for venues, hosts, artists, partners, classes, or schedules.

Create events from forms and spreadsheets

Turn partner submissions, Airtable records, Google Sheets rows, or admin forms into draft events ready for review.

Handle bulk and recurring event flows

Use backend jobs or automation tools to publish city-based imports, weekly sessions, recurring workshops, or high-volume calendars.

Retry safely without duplicate events

Use idempotency keys so failed jobs, webhook retries, and repeated submissions do not create duplicate event listings.

Create your first event request

Start with the required fields for a simple event. Add exact venue details, images, ticketing, and publishing options as your workflow grows.

Create a draft or published event

POST /api/public/v1/events

cURLJavaScriptOpenAPI

curl https://pinned.events/api/public/v1/events \
  -H "Authorization: Bearer pe_test_your_prefix_your_secret" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: event-api-launch-2026-06-12" \
  -d '{
    "channelId": 42,
    "title": "API Launch Workshop",
    "startAt": "2026-06-12T18:00:00-04:00",
    "timezone": "America/New_York",
    "classifications": ["music"],
    "approxLocation": {
      "city": {
        "placeId": "place-new-york",
        "name": "New York",
        "countryCode": "US"
      }
    }
  }'

From your source system to a Pinned Events channel

Create a scoped key, choose the channel, send the event payload, and retry safely when jobs or webhooks fail.

1/developers/keys
Create a scoped API key
Sign in, complete account setup, and create a key for the integration that will publish events.
2GET /api/public/v1/channels
Choose the channel
List only the channels available to the key owner and choose where the event should appear.
3POST /api/public/v1/events
Send the event
Publish event data from your source system or automation workflow.
4Idempotency-Key
Retry without duplicates
Add an idempotency key so repeated requests do not create duplicate events.

Safe enough for real automation

Publishing into discovery channels should stay controlled. Every request is tied to API keys, scopes, channel access, rate limits, idempotency, and audit metadata.

Scoped API keys

Give each integration only the permissions it needs, starting with channel read and event create.

One-time secrets

Full API key secrets are shown only once and are never returned from list endpoints.

Channel access checks

Channel access is checked at request time, even if permissions change after the key was created.

Duplicate-safe retries

Idempotency keys help jobs and webhooks retry after failures without creating duplicate events.

Rate limits

Route-level limits protect the platform and keep busy workflows predictable.

Audit metadata

Key usage and revocation metadata help teams understand and control API access.

Developer resources

Everything needed to connect your publishing workflow and move from first request to production automation.

Ready to bring your events into Pinned Events?

Create a scoped API key, connect your event source, and publish your first event into a channel people can discover.