Kenso MCP tools

Outbound Events outbound_events

Conferences and trade shows you work (Event outbound): each event and its attendee, exhibitor, speaker and sponsor list, every row matched to your target accounts by company domain, and the events Ken suggests to add. Not analytics events: those are analytics.

Call it from an MCP client connected to https://mcp.ken.so/mcp: reads go through outbound_events_read and changes through outbound_events_write. Each takes operation plus that operation's parameters, and your workspace role decides which operations you see.

Each operation with a route calls the Kenso API at https://api.ken.so with Authorization: Bearer <Kenso API key>, Ken-Version: 1.1 and X-Ken-Workspace-Id: <workspace id>. You can call that route directly with the same headers.

Operations: suggestions-accept, attendees-bulk-create, create, attendees-delete, delete, suggestions-dismiss, extract-attendees, find-company-people, find-last-year, find-people-going, get, linkedin-attendees, attendees-list, suggestions-list, list, plan-touches, preview-from-link, read-linkedin-attendees, update, attendees-upload

suggestions-accept

Write. Early access: needs accounts, event_outbound on for the workspace. POST https://api.ken.so/v1/outbound-event-suggestions/{suggestionId}/accept

Path: suggestionId

Body (json): attendance string

Add a suggested event to the workspace's events. Returns the suggestion and the new event. Then add its attendee list with operation attendees-bulk-create.

POST /api/v1/outbound-event-suggestions/{suggestionId}/accept. Staff. Sends Ken-Version
1.1 and X-Ken-Actor: agent. Creates the event from the suggestion's name, dates,
timezone, format, city, venue and url, and marks the suggestion added with its eventId.
attendance: going or not_going, the new event's attendance; left out, the event is not
decided (null). Returns 200 with {suggestion, event}. A suggestion already added or
dismissed is 409 invalid_state; another workspace's suggestion is not_found.

attendees-bulk-create

Write. Early access: needs accounts, event_outbound on for the workspace. POST https://api.ken.so/v1/outbound-events/{eventId}/attendees/bulk-create

Path: eventId

Body (json): items array, source string, sourceUrl string

Add up to 500 attendees, exhibitors, speakers or sponsors to an event in one call. Each result is created, duplicate (the row already on the event) or validation_failed.

POST /api/v1/outbound-events/{eventId}/attendees/bulk-create. Staff. Sends Ken-Version
1.1 and X-Ken-Actor: agent. source: where the list came from (required): csv, url,
manual, api, paste (pasted text), xlsx, pdf or image (a badge, card or list photo),
prospectus (companies from a prospectus or who-attends page), or the source a find
operation returned with each person: company_people (people at a listed company, likely
there), profile_mention (their profile names the event), inbox_mention (they said so
in a reply) or last_year (on last year's speaker, sponsor or exhibitor list); or
linkedin_post (their public LinkedIn post says they take part).
source_url: the page the list came from (http or https). items: 1 to 500 rows, each
{role, full_name?, first_name?, last_name?, title?, email?, linkedin_url?,
company_name?, company_domain?}. role is attendee, exhibitor, speaker or sponsor. A
row names a person (full name, first and last name, email or LinkedIn URL) or a
company. company_domain takes a domain, website URL or work email; without it, a
work email's domain is used.
Returns 200 with {succeeded, failed, results[]} in request order: created (with id),
duplicate (with the id of the row already on the event with the same role and the
same email, else LinkedIn URL, else name and company, else company; counts as
succeeded) or validation_failed (with error). A duplicate fills the stored row's
blank title and company_domain from the item; a filled company_domain marks the row
matched (source input), so resending a row with its domain corrects an unmatched
one. Rows with no company domain are looked up in Kenso Search during the call
(company by name, person by first name, last name and company); a failed lookup
marks the row failed and never fails the call, and sending the row again retries it.

create

Write. Early access: needs accounts, event_outbound on for the workspace. POST https://api.ken.so/v1/outbound-events

Body (json): attendance string, city string, endsOn date, format string, name string, startsOn date, timezone string, url string, venue string

Create an outbound event (a conference the workspace works). Returns 201 with the event. Then add its attendee list with operation attendees-bulk-create.

POST /api/v1/outbound-events. Staff. Sends Ken-Version 1.1 and X-Ken-Actor: agent.
name: 1 to 200 characters. starts_on: YYYY-MM-DD, required. ends_on: YYYY-MM-DD,
default starts_on, never before it. timezone: an IANA id such as America/Chicago
(the event's status uses it). format: in_person (default), virtual or hybrid. city
and venue: up to 200 characters. url: http or https, up to 2048 characters.
attendance: going or not_going; left out, the event is not decided (null).

attendees-delete

Write. Early access: needs accounts, event_outbound on for the workspace. DELETE https://api.ken.so/v1/outbound-event-attendees/{attendeeId}

Path: attendeeId

Remove one attendee, exhibitor, speaker or sponsor row from its event. Returns 204. Only on the user's request.

DELETE /api/v1/outbound-event-attendees/{attendeeId}. Staff. Sends Ken-Version 1.1 and
X-Ken-Actor: agent. Soft delete; the same row can be added again afterwards. A row of
another workspace, or of a deleted event, is not_found.

delete

Write. Early access: needs accounts, event_outbound on for the workspace. DELETE https://api.ken.so/v1/outbound-events/{eventId}

Path: eventId

Delete an outbound event and hide its attendee list. Returns 204. Only on the user's request.

DELETE /api/v1/outbound-events/{eventId}. Staff. Sends Ken-Version 1.1 and X-Ken-Actor: agent.
Soft delete. Another workspace's event is not_found.

suggestions-dismiss

Write. Early access: needs accounts, event_outbound on for the workspace. POST https://api.ken.so/v1/outbound-event-suggestions/{suggestionId}/dismiss

Path: suggestionId

Dismiss a suggested event. Ken never suggests it again. Only on the user's request.

POST /api/v1/outbound-event-suggestions/{suggestionId}/dismiss. Staff. Sends
Ken-Version 1.1 and X-Ken-Actor: agent. Marks the suggestion dismissed; its URL and
name stay known, so discovery skips the event from then on. Returns 200 with the
suggestion. A suggestion already added or dismissed is 409 invalid_state; another
workspace's suggestion is not_found.

extract-attendees

Write. Early access: needs accounts, event_outbound on for the workspace. POST https://api.ken.so/v1/outbound-events/{eventId}/extract-attendees

Path: eventId

Body (json): mode string, role string, text string, url string

Read an event's speaker, exhibitor, sponsor or attendee page, or a pasted list, and return its rows to review. Nothing is saved: add the rows you keep with operation attendees-bulk-create.

POST /api/v1/outbound-events/{eventId}/extract-attendees. Staff. Sends Ken-Version 1.1
and X-Ken-Actor: agent. Exactly one of url (the page, http or https, up to 2048
characters) or text (a pasted list, up to 120,000 characters). role: attendee,
exhibitor, speaker or sponsor, for the rows the model finds. A url is read from the
site first, free: a platform list the link names or the page embeds for that role
(Sched, Sessionize, a2z, ExpoFP, Luma) answers with no model call, each row with the
platform's role, up to 500. Else the page's text, data and up to 5 next pages go to the
model (Kenso's archive copy instead when fuller; with none, a paid live read when the
workspace can); up to 300 rows from the first 120,000 characters. Text goes to the
model in parts of 20,000 characters, every row with the role. Model calls are not
charged. mode: attendees (default) or prospectus: a sponsorship prospectus or
who-attends page, read for the companies it names (rows with companyName and
companyDomain only, each with the role), the job titles it says attendees hold
(titleMix) and how many attend (attendeeCount); platform lists are skipped and a url is
never read live. Add those rows with source="prospectus", then pass titleMix's titles
to outbound_events(operation="find-company-people", titles=[...]).
Returns 200 with {url, source, reader, rows, truncated, total, note, pages, titleMix,
attendeeCount}. titleMix: [{title, share}] (share a fraction 0-1, or null), empty
outside prospectus mode; attendeeCount: a number, else null. source:
direct, archive, live, none (unreadable; no rows) or text (pasted text; no url).
reader: the platform, or generic. rows: [{role, fullName, firstName, lastName, title,
email, linkedinUrl, companyName, companyDomain}], normalized like bulk-create, unset
fields omitted. truncated: a cap or a failed part cut the list. total: the platform's
own count, else null. note: what to tell the person (a host-only guest list, a list
closed to crawlers), else null. pages: [{url, role, label}], the site's other list
pages to read next. A model that fails also returns no rows. Pass the rows you keep to
outbound_events(operation="attendees-bulk-create", event_id=..., source="url",
source_url=<url>, items=<rows>), or source="paste" for text. A list file (CSV, Excel,
PDF, photo) goes to outbound_events(operation="attendees-upload", ...).

find-company-people

Write. Early access: needs accounts, event_outbound on for the workspace. POST https://api.ken.so/v1/outbound-events/{eventId}/find-company-people

Path: eventId

Body (json): limit integer, nearEventCity boolean, perCompany integer, titles array

Find people at the event's exhibitor, sponsor and listed companies with Kenso Search, as a preview. Nothing is saved: add the people you keep with operation attendees-bulk-create.

POST /api/v1/outbound-events/{eventId}/find-company-people. Staff. Sends Ken-Version 1.1
and X-Ken-Actor: agent. titles: 1 to 20 job titles (a prospectus's titleMix titles, or
what the person typed); default the roles that staff a booth (sales, marketing,
partnerships, business development, account executives, events, founders). A current
title matches when it holds every word of one. near_event_city: true keeps only people
whose profile city is the event's city (ignored when the event has none). per_company:
3 to 10 people per company (default 5). limit: 1 to 200 people (default 200). The
companies are the event's exhibitor and sponsor rows and its rows with no person (the
companies a prospectus named), sponsors first, at most 100 per call; each is found in
Kenso Search by its domain, else by a name only one company has. People already on the
event are left out.
Returns 200 with {people, truncated, companyCount, phrase, note}. people: [{source,
isLikely, reason, row, contactId, threadId, repliedAt}], source company_people,
isLikely true (they work at a listed company and may not go: call them likely and write
"your team is exhibiting at <event>", never "saw you're attending"), reason ("Works at
Northwind: their team is exhibiting"), row {role, fullName, firstName, lastName, title,
linkedinUrl, companyName, companyDomain} with the company's role. companyCount: the
companies Kenso Search looked at. truncated: the limit or the 100-company cap cut the
list. note: what to tell the person (no companies on the list, Kenso Search unavailable),
else null. Each profile returned counts against the workspace's Search browse quota
(429 quota_exceeded past it). Another workspace's event is not_found. Add the people
you keep with outbound_events(operation="attendees-bulk-create", event_id=...,
source="company_people", items=[row, ...]).

find-last-year

Write. Early access: needs accounts, event_outbound on for the workspace. POST https://api.ken.so/v1/outbound-events/{eventId}/find-last-year

Path: eventId

Body (json): limit integer, url string

Find last year's speakers, sponsors and exhibitors for the event, from its site or the Wayback Machine, as a preview. Nothing is saved: add the rows you keep with operation attendees-bulk-create, source last_year.

POST /api/v1/outbound-events/{eventId}/find-last-year. Staff. Sends Ken-Version 1.1 and
X-Ken-Actor: agent. url: the event's site to look at (its home page or a speaker,
sponsor or exhibitor page, http or https, up to 2048 characters); default the event's
url, and required when the event has none. limit: 1 to 500 people (default 500). The
year is the one before the event's start date. Free and read straight from the site
(robots.txt obeyed, never Firecrawl): a link with the year in it is moved back a year
and read live (Sched kccncna2025.sched.com, a2z FABTECH2025), else the page's latest
Wayback Machine copy from last year and the list pages it linked, else one Wayback
lookup across the site. At most 4 pages, each through the extract-attendees readers: a
platform list answers with no model call, any other page goes to the model (not
charged). Common Crawl is not asked (its robots.txt closes it to crawlers). People
already on the event in the same role are left out.
Returns 200 with {year, lists, people, truncated, note}. lists: [{url, archiveUrl,
capturedAt, role, reader, count, truncated, note}], one per page read; archiveUrl and
capturedAt are set for a Wayback copy. people: [{source, lastYear, isLikely, reason,
pageUrl, capturedAt, row}], source last_year, lastYear true, isLikely true (they were
there last year: call them likely and write "you spoke at <event> last year", never
"saw you're attending"), reason ("Sponsor in 2025 on saastrannual.com/sponsor (archived
Oct 6, 2025)"), row {role, fullName, firstName, lastName, title, linkedinUrl,
companyName, companyDomain}. Companies come back more often than people (63% of
FABTECH's exhibitors returned, 31% of KubeCon's speakers). truncated: a page, row or time cap cut
the list. note: what to tell the person (no page found, the archive did not answer),
else null. Another workspace's event is not_found. Add the rows you keep with
outbound_events(operation="attendees-bulk-create", event_id=..., source="last_year",
items=[row, ...]).

find-people-going

Write. Early access: needs accounts, event_outbound on for the workspace. POST https://api.ken.so/v1/outbound-events/{eventId}/find-people-going

Path: eventId

Body (json): limit integer, name string

Find people who say they are going to the event: inbox replies and Kenso Search profiles that name it. A preview: add the people you keep with operation attendees-bulk-create.

POST /api/v1/outbound-events/{eventId}/find-people-going. Staff. Sends Ken-Version 1.1
and X-Ken-Actor: agent. name: the event name to look for, up to 100 characters; default
the event's name without its year, city or a part in brackets ("Web Summit Lisbon 2026"
is "Web Summit"). limit: 1 to 100 people (default 50). First come inbound campaign
replies in this workspace's inbox (not bounces or automated replies) from the year
before the event until it ends whose own words (the quoted email cut off) name it as
somewhere the writer goes ("see you at Slush", or the name before the event's year)
and do not decline it ("I won't be at Slush"): source inbox_mention, with contactId,
threadId (thr_) and repliedAt. Then Kenso Search profiles whose headline, summary or
current title name it, not the organizer's staff nor a profile naming only a past
edition: source profile_mention, those naming it with the event's year first, then those
naming it alone, unless the name alone is on more than 2,000 profiles (common words),
when only the year matches count. LinkedIn posts are not in Kenso Search: a person whose
public LinkedIn post says they take part comes as source linkedin_post, never from this
operation. People already on the event are left out.
Returns 200 with {people, truncated, companyCount, phrase, note}. people: [{source,
isLikely (false: they named the event themselves), reason ("Replied Mar 3: ...",
"Headline: Speaker at RevOps Summit 2026"), row (role attendee), contactId, threadId,
repliedAt}]. phrase: the name looked for. note: what to tell the person, else null.
Each profile returned (not the replies) counts against the workspace's Search browse
quota (429 quota_exceeded past it). Another workspace's event is not_found. Add the
people you keep with outbound_events(operation="attendees-bulk-create", event_id=...,
source=<their source>, items=[row, ...]), one call per source.

get

Read. Early access: needs accounts, event_outbound on for the workspace. GET https://api.ken.so/v1/outbound-events/{eventId}

Path: eventId

Return one outbound event with its counts.

GET /api/v1/outbound-events/{eventId}. Staff. Sends Ken-Version 1.1 and X-Ken-Actor: agent.
Same fields as the list, posts included. Another workspace's event, or a deleted one, is not_found.

linkedin-attendees

Read. Early access: needs accounts, event_outbound on for the workspace. GET https://api.ken.so/v1/outbound-events/{eventId}/linkedin-attendees

Path: eventId

Show the LinkedIn event read for an event: the warning, the limits, your seats and the latest reads. Read this, and show the warning to the person, before operation read-linkedin-attendees.

GET /api/v1/outbound-events/{eventId}/linkedin-attendees. Staff. Sends Ken-Version 1.1
and X-Ken-Actor: agent. Answers while the feature is switched off too.
Returns 200 with {enabled, warning, note, limits, event, seats, reads}. enabled: false
while LinkedIn event reads are switched off (no read can start). warning: the text the
person must read and accept before every read: automated reads break LinkedIn's User
Agreement (section 8.2) and can get the seat restricted, the read uses the seat's search
budget, and the seat must already be attending the event (Ken never clicks Attend).
limits: {attendeesPerRead 100, attendeesPerEvent 300, hoursBetweenEventReads 24,
readsPerSeatPerDay 2, attendeesPerSeatPerDay 200, secondsBetweenPages 30, seatPauseHours
72}. event: {attendeesCounted, attendeesLeft, nextReadAt}. seats: the LinkedIn seats the
caller connected, each {linkedInAccountId, name, canRead, allowance, refusal, message,
availableAt, readsToday, attendeesToday, pausedUntil}; refusal is seat_unavailable,
seat_paused, event_cooldown, event_limit, seat_reads_today or seat_limit. reads: the
event's latest 5 reads, newest first, each {id, status (queued, reading, done, failed),
stopReason, message, maxAttendees, pagesRead, attendeeCount, rows, eventUrl, nextPageAt}.
rows are normalized like bulk-create (role attendee, the LinkedIn headline as title):
review them with the person and add the ones they keep with
outbound_events(operation="attendees-bulk-create", event_id=..., source="url",
source_url=<eventUrl>, items=<rows>). Another workspace's event is not_found.

attendees-list

Read. Early access: needs accounts, event_outbound on for the workspace. GET https://api.ken.so/v1/outbound-events/{eventId}/attendees

Path: eventId

Query: account string, cursor string, limit integer, role string, source string

List an event's attendees, exhibitors, speakers and sponsors, each with its matched account. account=matched lists the rows on your target accounts; source=linkedin_post the people found in LinkedIn posts.

GET /api/v1/outbound-events/{eventId}/attendees. Staff. Sends Ken-Version 1.1 and
X-Ken-Actor: agent. role: comma-separated, any of attendee, exhibitor, speaker,
sponsor. account: matched (the row's company domain belongs to a live account) or
unmatched. source: one row source (linkedin_post: people found in public LinkedIn posts).
limit 1 to 500 (default 100), oldest first; pass pagination.nextCursor
back unchanged with the same filters. Each row: id, eventId, role, fullName,
firstName, lastName, title, email, linkedinUrl, companyName, companyDomain, source,
sourceUrl, match {status: pending|matched|unmatched|failed, source: input|ken_search},
account ({id, name, stage, eventTouch {id, status} or null} or null), personId (a
person in the workspace with the row's email, else its LinkedIn URL), stakeholderId
(that person on that account), kenPersonId (the person's Kenso Search id, set when a
people match found them there; an Event attendees workflow source runs a named row
with an email, a LinkedIn URL or a kenPersonId), proof {url, postedAt, quote} and
confidence (0-100) of a linkedin_post row, createdAt. Unset fields are null.

suggestions-list

Read. Early access: needs accounts, event_outbound on for the workspace. GET https://api.ken.so/v1/outbound-event-suggestions

Query: cursor string, limit integer, status string

List the events Ken suggested for the workspace, most relevant first. Add one with operation suggestions-accept or drop it with suggestions-dismiss.

GET /api/v1/outbound-event-suggestions. Staff. Sends Ken-Version 1.1 and X-Ken-Actor:
agent. status: suggested (default; hides events that already ended in their own
timezone, else UTC), added or dismissed. limit 1 to 200 (default 50), ordered by
relevance then newest; pass pagination.nextCursor back unchanged with the same status.
Each suggestion: id, name, startsOn, endsOn (YYYY-MM-DD), timezone, format (in_person,
virtual or hybrid), city, venue, url, source (luma, dev_events, allevents or meetup;
eventbrite, tentimes or conferenceindex where Ken reads them through Firecrawl for
the workspace; eventbrite or linkedin from a workflow's Apify actor), sourceUrl (the
listing it was found on; null for an Apify actor's events),
relevance (0 to 100), reason (why it fits the workspace), accounts
[{accountId, name, role}] (the workspace's accounts seen on it), status, eventId (the
event it became once added), createdAt, decidedAt. Unset fields are null.

list

Read. Early access: needs accounts, event_outbound on for the workspace. GET https://api.ken.so/v1/outbound-events

Query: cursor string, limit integer, status string

List the workspace's outbound events (conferences, trade shows), newest first, with counts. status: upcoming, past or all (default).

GET /api/v1/outbound-events. Staff. Sends Ken-Version 1.1 and X-Ken-Actor: agent.
status: upcoming (the event ends today or later, in its own timezone, else UTC),
past (it ended before today) or all (default). limit 1 to 200 (default 50); pass
pagination.nextCursor back unchanged with the same status. Each event: id, name, startsOn, endsOn (YYYY-MM-DD),
timezone, format (in_person, virtual or hybrid), attendance (going, not_going, or null when not decided), city, venue,
url (null when unset), status (upcoming, live or past, from
its dates in its own timezone, else UTC), counts {attendees, speakers, exhibitors,
sponsors, companies, accounts}, posts, createdAt, updatedAt. counts.accounts is the number
of distinct live accounts whose domain a row carries. posts (people from public LinkedIn
posts; null while off): {status: not_started|queued|searching|checked, lastCheckedAt,
addedCount, spentMillicredits, spendLimitMillicredits, waitingCount and waitingMillicredits
(found, not added yet), checkAgainAt}, in millicredits (1,000 = 1 credit).

plan-touches

Write. Early access: needs accounts, event_outbound on for the workspace. POST https://api.ken.so/v1/outbound-events/{eventId}/plan-touches

Path: eventId

Body (json): dueAt date-time

Plan an Event touch (meet them at the event) for every target account on the event's list. The touches wait for a person to approve them in Today; nothing is sent.

POST /api/v1/outbound-events/{eventId}/plan-touches. Staff. Sends Ken-Version 1.1 and
X-Ken-Actor: agent. due_at: ISO-8601 instant (UTC when no offset); default 09:00 UTC
fourteen days before the event starts, or now when that has passed. One touch per
attending account (channel event, title "Meet at {event}", a body naming the event,
its dates and city and the people from that account on the list, speakers first) on
the person on the list who is a stakeholder of the account (speaker, then attendee,
exhibitor, sponsor), awaiting approval in Today. An account whose Event touch for this
event already exists counts in touchesExisting. Accounts in stage paused, not_a_fit or
lost are skipped (reason stage_paused, stage_not_a_fit or stage_lost), and so is an account the
workspace's touch guardrails block (reason: the rule, for example
min_days_between_touches). Speakers on the list also become event signals on their
accounts. Safe to call again. Nothing is sent: the touches wait for a person to
approve each one in Today.
Returns 200 with {accounts, touchesCreated, touchesExisting, skipped [{accountId,
reason}], signalsCreated}. An event that is over (status past: it ended before today
in its timezone, else UTC) is 409 invalid_state; another workspace's event is not_found.

Read. Early access: needs accounts, event_outbound on for the workspace. POST https://api.ken.so/v1/outbound-events/preview-from-link

Body (json): url string

Preview an event from its page (Luma, Eventbrite, Sched or the event's site). Saves nothing.

POST /api/v1/outbound-events/preview-from-link. Staff. url: http(s), up to 2048
characters, read straight from the site (robots.txt obeyed, never Firecrawl). Fields
come from the page's schema.org Event (json_ld), then Luma or Eventbrite page data
(add the timezone); one Claude Haiku call (model) only when neither names an event.
Quota outboundEventLinkPreviews: 30 an hour, 200 a day (429 quota_exceeded).
Returns {url, platform, event, sources, missing, pages, note}. event: the fields
operation create takes; one the page does not state is left out. sources: per field.
missing: the fields to ask the person for. pages: [{url, role, label}], the site's
list pages; once the event exists read each with outbound_events(
operation="extract-attendees", event_id=..., url=..., role=...). note: why nothing
was read, else absent.

read-linkedin-attendees

Write. Early access: needs accounts, event_outbound on for the workspace. POST https://api.ken.so/v1/outbound-events/{eventId}/read-linkedin-attendees

Path: eventId

Body (json): acceptWarning boolean, linkedInAccountId integer, url string

Start reading a LinkedIn event's attendee list through one of your LinkedIn seats, into rows to review. Show the person the warning from operation linkedin-attendees first, and pass accept_warning=true only once they accept it.

POST /api/v1/outbound-events/{eventId}/read-linkedin-attendees. Staff. Sends Ken-Version
1.1 and X-Ken-Actor: agent. url: the LinkedIn event link
(https://www.linkedin.com/events/<id>/ or the event's attendee search link).
linkedin_account_id: one of the caller's own connected seats (seats in
outbound_events(operation="linkedin-attendees")). accept_warning: true once the person
read and accepted the warning: automated reads break LinkedIn's User Agreement (section
8.2) and can get this seat restricted; the read uses this seat's search budget; the
seat must already be attending the event (Ken never clicks Attend).
The worker reads the seat's LinkedIn people search filtered by the event, 10 people a
page, at least 30 seconds apart. Hard limits, enforced by the worker too: 100 attendees
a read; one read of an event every 24 hours and 300 attendees per event; 2 event reads
and 200 attendees per seat per UTC day. The first rate limit or restriction sign stops
the read and pauses event reads on the seat for 72 hours. An empty list ends the read
as no_attendees ("LinkedIn returned no attendees: make sure this seat clicked Attend on
the event."), with no retry. Nothing lands on the event: poll
outbound_events(operation="linkedin-attendees") for the read and its rows.
Returns 202 with the read {id, status queued, maxAttendees, eventUrl, ...}. Switched off
is 409 invalid_state (switched_off); a limit is 409 invalid_state with the limit code
(event_cooldown, event_limit, seat_paused, seat_reads_today, seat_limit); a bad link is
validation_failed (invalid_linkedin_event_url); another member's or an unusable seat is
validation_failed (linkedin_account_unavailable); no accepted warning is
validation_failed (warning_not_accepted).

update

Write. Early access: needs accounts, event_outbound on for the workspace. PATCH https://api.ken.so/v1/outbound-events/{eventId}

Path: eventId

Body (json): attendance string, city string, endsOn date, format string, name string, postSpendLimitMillicredits integer, startsOn date, timezone string, url string, venue string

Update an outbound event. Absent keys stay unchanged. changes keys: name, starts_on, ends_on, timezone, format, attendance, city, venue, url, post_spend_limit_millicredits.

PATCH /api/v1/outbound-events/{eventId}. Staff. Sends Ken-Version 1.1 and X-Ken-Actor: agent.
name, starts_on and format cannot be null. ends_on null resets it to starts_on; the
end cannot be before the start. attendance (going or not_going), timezone, city, venue
and url accept null to clear. Same values and limits as create.
post_spend_limit_millicredits: the most Kenso may spend adding people from LinkedIn posts,
0 to 100,000,000 millicredits (1,000 = 1 credit); 0 pauses adding. Example:
{"ends_on": "2026-09-12", "venue": null, "attendance": "going"}.

attendees-upload

Write. Early access: needs accounts, event_outbound on for the workspace.

Add an event's attendees from a list file (CSV, Excel, PDF, badge or list photo) or pasted text. Reads it the way the app does and adds the rows; preview=true only reads them (do that first for a PDF or photo).

Staff. Sends Ken-Version 1.1 and X-Ken-Actor: agent. Ask the person first whether they have
permission to use the list, as the app does. Pass exactly one of file_content_base64 (the file's
bytes in base64) with file_name, or text. The hosted MCP refuses file_path, because it cannot read
your machine; off the hosted MCP, file_path opens only a file inside the MCP export directory.
role: attendee, exhibitor, speaker or sponsor, for every row (a table's Role column, such as
"Speakers", wins for its row). One file per call, at most 10 MB.

- .csv (or text with file_name="list.csv", the CSV's text): read here like the app. The first
  non-blank line is the header; up to 5,000 rows. Columns map by name: Role; Full name or Name;
  First name; Last name; Title or Job title; Email; LinkedIn or LinkedIn URL; Company, Company
  name or Organization; Domain, Website or Company domain (case, spaces, _ and - ignored).
  columns overrides that: {"Org": "company_name", "Notes": null}, a column name to a field
  (role, full_name, first_name, last_name, title, email, linkedin_url, company_name,
  company_domain) or null to skip it. Blank cells and a domain cell that is not a domain are left
  out; a row with nothing left is dropped (dropped counts them). Rows go in with source csv.
- .xlsx: POST /api/v1/outbound-events/{eventId}/extract-attendees (files form). Kenso returns its
  first visible sheet (no model call), mapped like a CSV. Source xlsx.
- .pdf, .jpg, .jpeg, .png, .webp: the same files form. A PDF's text (first 40 pages) is read by
  the model; a scan with no text is no_text, so send photos of its pages. Each photo (at most
  3.75 MB and 8,000 px on a side; HEIC is not read: send it as JPEG) is one Claude vision call,
  at most 3 at a time. Source pdf or image.
- text alone: a pasted list. A table copied from a sheet (tabs) or a CSV whose header names a
  field above maps the same way; any other text (names, an email, a doc, up to 120,000
  characters) goes to POST /api/v1/outbound-events/{eventId}/extract-attendees as text. Source
  paste.
The model calls are not charged. Then, unless preview, the rows go to POST
/api/v1/outbound-events/{eventId}/attendees/bulk-create 500 at a time. The app shows the person
the rows a model read before adding them: for a PDF, a photo or free text, call with preview=true,
show the rows, then add the ones they keep with outbound_events(operation="attendees-bulk-create",
event_id=..., source=<source>, items=<rows>), which reads nothing again. A table maps the same way
every time, so add it directly (preview=true to check the columns first). A failed first batch is
the call's error. A later one stops the call: added carries the counts so far, error and
stoppedAtIndex (the first row not sent); sending the list again is safe (rows already on the event
come back duplicate).
Returns {eventId, source, file, columns, rowsRead, dropped, note, truncated, added} and, with
preview, items (the rows bulk-create would get, the first 300; itemsTruncated says more were
read). file: {name, kind (spreadsheet, pdf, image or
other), status (read, skipped or failed), reason, truncated}, null for pasted text. A file Kenso
did not read has its reason (unsupported_type, too_large, no_text, oversized_image, unreadable,
extraction_failed: try again) and adds nothing. columns: [{column, field}] for a table, else
null. note: what to tell the person about pasted text, else null. added: {created, duplicate,
failed, failures [{index, row, error}], the first 20}. Another workspace's event is not_found.