CRM API reference

Every endpoint of the CRM API, what each key needs, the startup each request is for, the errors, and what a webhook posts.

For foundersUpdated Nov 9, 2026

The address of every endpoint starts with https://startupcorners.com/api/v1. Send your key as Authorization: Bearer sc_live_... and JSON with Content-Type: application/json. Answers are JSON. To make a key, see Send leads to your CRM with the API.

Which startup

Add ?entity= to any address with the startup's address name (the part after /s/ in its link) or its id, for example /objects/contacts/records?entity=kumo-labs. A key that reaches one startup can leave it out.

Method and address
Needs
What it does
GET /entities
any key
The startups the key reaches: [{ "id", "slug", "name" }]. Needs no ?entity=.

Contacts

Your CRM is one table of contacts. Each contact is a person or an organization: its kind, in every answer. The object is contacts (or a custom object's key, or an id). people and companies still work: they are contacts of that kind, reading only that kind and making new ones of it, and their answers keep "object": "people" or "companies". deals answers 410 gone: deals are now entries in the Customers list, at /lists/customers/entries. Fields are named by their key; a field renamed by the change keeps its old key too (type is now Category). A field with kinds is only for that kind (Job title for people, Domain for organizations).

Method and address
Needs
What it does
GET /objects
records:read
Every object with its fields.
GET /objects/{object}/attributes
records:read
One object's fields: key, type, and choices.
POST /objects/{object}/attributes
schema:write
Adds a field from { "name", "type", "unique", "options" } (unique and options optional). 201 added, 200 with the field that already has that name.
POST /objects/{object}/attributes/{attribute}/options
schema:write
Adds choices to a select or multi select field (by key, id or name) from { "options": [{ "label", "color" }] } (color optional). A choice already there is skipped. { "data": <the field>, "added": [...] }, 201 when one was added, else 200.
GET /objects/{object}/records
records:read
Contacts, 100 at a time. kind (person or organization) keeps one kind; q searches names; filter is a JSON list of { "attribute", "op", "value" } that must all match, or { "join": "or", "rules": [...] } (rules and one level of groups, 20 rules at most); sort is key:asc or key:desc; tz is the time zone relative dates count in; view (contacts only) gives the contacts a saved view of the CRM's All table shows, by its name or id, narrowed by filter; cursor gets the next 100.
POST /objects/{object}/records
records:write
Adds a contact from { "kind", "values": { ... } } (kind person, the default, or organization). 409 duplicate when its email or domain is already on one. Add "list" (and "stage") to also put it in a type.
PUT /objects/{object}/records?matching_attribute=email
records:write
Updates the person with that email (or the organization with that domain, or any field made unique, like profile_url), else adds it. 201 added, 200 updated. Takes "kind", "list" and "stage" too.

A type is a list of contacts: Investors (fundraising), Customers (customers), Network (network) and the ones you add. Anyone of either kind can be in any type. "list" is a type's key or id and "stage" its stage's label, else the first. The contact and its entry are saved together: an unknown stage saves nothing. With "list" the key also needs lists:write (403 forbidden without it), and the answer has the record's entry. Sent again for a record already there, it moves the entry to the stage given. | GET /records/{id} | records:read | One record, its pipeline entries and its latest notes. | | PATCH /records/{id} | records:write | Changes the fields in { "values": { ... } } and leaves the others. | | DELETE /records/{id} | records:write | Deletes the record: it leaves every pipeline, and its email or domain is free again. | | POST /records/{id}/notes | notes:write | Adds a note from { "text": "..." }. A blank line starts a new paragraph. Add "created_at": "2026-10-23" to date it on a past day. | | DELETE /records/{id}/notes/{noteId} | notes:write | Deletes one note for good (GET /records/{id} lists the notes with their ids). Only the note's author, or an admin. |

A text or link field can be made unique when it is added ("unique": true, or Each value only once in the New field window). Then no two records share its value, and matching_attribute can name it. Links match however they are written: with or without https:// or www., a slash at the end, or tracking after ?.

Values: a choice by its label ("stage": "Intro sent"), an amount as { "amount": 250000, "currency": "USD" }, a date as 2026-10-28, a person's company as { "domain": "acme.com", "name": "Acme" }.

Types (pipelines)

A type is named by its key (fundraising, customers) or its id. Each has singular, its word for one ("Investor"), and a color.

Method and address
Needs
What it does
GET /lists
lists:read
The types with their stages.
POST /lists
schema:write
Adds a type from { "name", "singular", "stages": [{ "label", "kind" }] }, where kind is open, won or lost (singular optional; it is a list of contacts). 201 added, 200 with the type that already has that name.
POST /lists/{list}/attributes
schema:write
Adds a field to the pipeline's entries from { "name", "type", "options" }.
POST /lists/{list}/attributes/{attribute}/options
schema:write
Adds choices to a select or multi select field of the pipeline's entries, as for contacts.
GET /lists/{list}/entries
lists:read
Entries, 100 at a time, each with the contact's own fields in record.values when the key also has records:read. stage, q, tz and cursor narrow them, and filter as for records: stage, the entry's fields, and record. before a key for the contact's own fields. view gives the entries a saved view of the pipeline shows, by its name or id (two views with one name: use the id).
POST /lists/{list}/entries
lists:write
Puts a record in the pipeline from { "record_id", "stage", "values" } (stage and values optional). 201 added, 200 when it was there already.
PATCH /entries/{id}
lists:write
Moves it with { "stage": "Term sheet" }, or changes its fields with { "values": { ... } }.
DELETE /entries/{id}
lists:write
Takes the contact out of the pipeline. The contact and its notes stay.

A filter for the entries with a next step date before November and a stage of Messaged or Followed up:

[{ "attribute": "next_step_date", "op": "before", "value": "2026-11-01" },
 { "attribute": "stage", "op": "is_any_of", "value": ["Messaged", "Followed up"] }]

Besides fields, a filter's attribute can be:

  • a built-in: name, kind (person or organization), types (the types a contact is in, by key or name, with has_any, has_all, has_none), created_at, updated_at, last_contacted (the latest email, meeting or note), next_step, next_step_due and notes (the words in any of its notes with contains and not_contains, is_empty for no note);
  • a field of a linked contact, the link's key, a dot, then the field's key: "company.location";
  • a field of a type, the type's key, a colon, then the field's key: "fundraising:check_size" (the contact is in Investors and its check size matches).

People whose company is in Japan and who are in Investors with a check size of at least $250,000:

[{ "attribute": "kind", "op": "is", "value": "person" },
 { "attribute": "company.location", "op": "contains", "value": "Japan" },
 { "attribute": "fundraising:check_size", "op": "gte", "value": { "amount": 250000, "currency": "USD" } }]

The ops, by field type: text contains, not_contains, is, is_not, starts_with; numbers and amounts eq, neq, lt, lte, gt, gte, between (a pair); dates today, in_last, more_than_ago, in_next (with { "n": 7, "unit": "day" }, week or month, counted in the tz time zone, UTC when there is none), before, after, between; choices and stages is, is_not, is_any_of, is_none_of; several choices has_any, has_all, has_none; people is, is_not; links is_any_of, is_none_of (record ids). Most fields also take is_empty and not_empty.

Tables

Every table in the startup's Files, not only the CRM (see Make a table and count your CRM in it). A table's id is the id in its address in Files. Cells go by column name. CRM count and formula columns come worked out, and only when the key's maker can open that CRM; they cannot be written, nor can Created by, Edited by, Created, Edited and a relation's link back, which fill themselves in. A person cell reads as [{ "id", "name" }] and takes people of the table's company by id or name; a relation cell reads as [{ "id", "title" }] and takes rows of the linked table by id or title; a files cell reads as [{ "id", "name", "url" }] and takes file ids from Files the key's maker can open.

Method and address
Needs
What it does
GET /tables
tables:read
The startup's tables: [{ "id", "title", "folder", "rows", "updated_at", "url" }]. q narrows by title.
POST /tables
tables:write
Makes a table from { "title", "folder", "columns" } (folder and columns optional). 201 with the table.
GET /tables/{table}
tables:read
Its columns and rows, 200 at a time with cursor: { "columns", "rows": [{ "id", "cells": { "Name": "..." } }], "total", "next_cursor" }. sort (a column's name) with direction (asc or desc) and q (words in any shown cell) work over the whole table; keep them the same while paging. total counts the rows that match. totals gives the last row's totals by column name, over every matching row, for example { "Amount": "Sum 1,015" }, when a column has one. view (a saved view's name or id) gives the rows that view shows, with view describing it and, for a view that groups, groups: [{ "label", "count" }].
PATCH /tables/{table}
tables:write
Renames the table or moves it to another folder, from { "title", "folder" } (either one). Moving is for its owner or a file manager.
DELETE /tables/{table}
tables:write
Moves the table to the trash in Files, where it can be restored. For its owner or a file manager.
POST /tables/{table}/rows
tables:write
Adds 1 to 100 rows from { "rows": [{ "Variant": "LI-F-B", "Platform": "LinkedIn" }] }. A select takes a choice's label, a date YYYY-MM-DD. 201.
GET /tables/{table}/rows/{row}
tables:read
One row whole: { "id", "cells", "page", "comments": [{ "thread", "resolved", "comments": [{ "id", "by", "at", "text" }] }], "url" }, page being the row's own page in Markdown.
PATCH /tables/{table}/rows/{row}
tables:write
Changes cells with { "cells": { ... } }; cells not named keep their value, null empties one.
POST /tables/{table}/rows/{row}/comments
tables:write
Comments on the row from { "text", "thread" } (thread to reply), as the key's maker.
DELETE /tables/{table}/rows/{row}
tables:write
Removes the row.
PATCH /tables/{table}/columns
tables:write
Adds columns, or changes those with the same name, from { "columns": [...] }. The other columns stay. A relation column names its other table with table (its id or title, a table of the same startup), several: false for one row, and link_back: true to add the link back on that table; several: false keeps a person column to one person.
GET /tables/{table}/views
tables:read
The table's saved views, the tabs above it: { "data": [{ "id", "name", "kind", "groupBy", "dateColumn", "coverColumn", "filters", "sorts", "hidden", "url" }] }, columns by name. kind is table, board, calendar or gallery.
POST /tables/{table}/views
tables:write
Adds a view from { "name", "kind", "groupBy", "dateColumn", "coverColumn", "filters": [{ "column", "operator", "value" }], "sorts": [{ "column", "direction" }], "hidden": ["Column"] } (all but kind optional). A board's groupBy is a select or checkbox column; a table's may also be a multi-select or text column; a calendar's dateColumn is a date column. 201.
PATCH /tables/{table}/views/{view}
tables:write
Changes a view, named by its id or name: only what is sent changes.
DELETE /tables/{table}/views/{view}
tables:write
Deletes a view. The rows stay.

A column is { "name", "type" } with type text, number, select (with choices), multi-select, checkbox, date, url, crm-count or formula. A CRM count names its pipeline in list (key or id) and its conditions, each a field, an op and a value, or row_column for this row's value:

{ "name": "Replies", "type": "crm-count", "list": "outreach",
  "conditions": [{ "field": "variant", "op": "is", "row_column": "Variant" },
                 { "field": "replied", "op": "is", "value": true }] }

A formula has an expression with column names in braces, a format (number or percent) and decimals:

{ "name": "Reply rate", "type": "formula", "expression": "{Replies} / {Sends}", "format": "percent", "decimals": 0 }

Any column can also take a total, the figure under it in the table's last row: filled, empty, percent_filled or percent_empty (not a checkbox), unique (text, number, select, date, url), sum, avg, median, min or max (number, CRM count, formula), earliest or latest (date), checked or unchecked (checkbox). null removes it. To give an existing CRM count a total, name it with its type and the total only: its pipeline and conditions stay. A column's read shows its total.

Tasks

The startup's tasks, as its Tasks page lists them. A task is { "id", "title", "description", "status", "priority", "start_date", "due_date", "milestone", "tags", "assignee": { "id", "name" }, "completed_at", "created_at", "updated_at", "url" }. status is todo, in_progress, done or cancelled; priority is low, medium, high or urgent; dates are ISO 8601.

Endpoint
Scope
What it does
GET /tasks
tasks:read
The open tasks by due date, 100 at a time with cursor: { "data", "next_cursor" }. status lists one status, all=1 adds the done and cancelled ones, q finds words in the title or description.
GET /tasks/{task}
tasks:read
One task with its subtasks.
POST /tasks
tasks:write
Makes a task from { "title", "description", "status", "priority", "due_date", "start_date", "milestone", "tags", "assignee_id" } (only the title is needed), made by the key's owner. An assignee is told by email and push. 201 with the task.
PATCH /tasks/{task}
tasks:write
Changes the fields given; the others keep their value, null clears a date or the assignee. Moving its dates later moves the tasks that wait on it later too (followers_moved says how many), and finishing it tells its watchers.

A milestone needs its due_date. An assignee is someone on the startup's team.

Dashboards and charts

The dashboards of your CRM and of your tables (see See your CRM and tables as charts), and charts worked out on the spot. Read only: making and changing dashboards stays in the app and the assistant. A key sees the dashboards its maker sees. A type is named by its key or id in list; with no list, a chart is on All.

Method and address
Needs
What it does
GET /charts/fields
records:read
The fields a card can use on the type in list, or on All: { "data": [{ "key", "name", "type", "options" }], "example" }. options are the choices' labels; example is one card to copy.
POST /charts/query
records:read
Works out 1 to 6 cards from { "list", "cards", "filter" } (list and filter optional) without saving them. tz is the time zone dates count in. { "data": [{ "title", "words", "result" }] }, with error in place of result for a card that could not be worked out.
GET /dashboards
records:read
The type's dashboards with list, else every CRM dashboard, the team's first: { "data": [{ "id", "name", "type", "list_id", "cards", "shared_with_team", "can_change", "url" }] }. cards is how many.
GET /dashboards/{dashboard}
records:read
One CRM dashboard with its cards and their numbers (below). Takes tz.
GET /tables/{table}/dashboards
tables:read
The table's dashboards, { "data": [{ "id", "name", "table", "cards", "can_change", "url" }], "fields", "example" }, with the fields its cards use as /charts/fields gives them. A column's key is its id.
GET /tables/{table}/dashboards/{dashboard}
tables:read
One table dashboard with its cards and their numbers.
POST /tables/{table}/charts/query
tables:read
Works out 1 to 6 cards on the table, over every row, from { "cards", "filter" } (filter optional), without saving them. Answers as /charts/query.

A card is { "title", "kind", "measure" } and, as it needs them:

  • kind: number, bar, pie (6 slices at most), line (along a date), funnel (a type's stages) or stacked.
  • measure: count, sum, avg, min, max or percent. sum, avg, min and max take the key of a number or amount field in measureField; percent takes what counts as rules in percentWhere (5 at most).
  • groupBy: the field each bar or slice stands for, or the date a line goes along, with bucket day, week, month or quarter. splitBy: the field a stacked bar is split by.
  • filter: rules this card alone keeps to (8 at most). sort: value, label or field. limit: 3 to 12. compare: true for a number card with one in_last rule on a date, to get the period before too.

A rule is { "field", "op", "value" } with a field's key and an op among is, is_not, is_any_of, contains, more_than, less_than, in_last, before, after, is_empty, not_empty. The value is a choice's label, a number, true or false, YYYY-MM-DD for before and after, or { "n": 30, "unit": "day" } (week, month) for in_last. A query's filter is a list of rules every card keeps to, 8 at most, like a dashboard's filter.

Investors added per month over the last 6 months:

POST /charts/query?tz=Asia/Tokyo
{ "list": "fundraising",
  "cards": [{ "title": "Created per month", "kind": "line", "measure": "count", "groupBy": "builtin:created_at", "bucket": "month" }],
  "filter": [{ "field": "builtin:created_at", "op": "in_last", "value": { "n": 6, "unit": "month" } }] }
{ "data": [{ "title": "Created per month",
             "words": "Line over time: count of investors by Created, per month",
             "result": { "format": "count",
                         "points": [{ "label": "Sep 2026", "value": 4 }, { "label": "Oct 2026", "value": 9 }, { "label": "Nov 2026", "value": 2 }] } }] }

A result has a format (count, number, currency or percent), currency for money, value for a number card (and previous with compare), points with a label and a value (a stacked bar's values by split), and a note when something was left out.

A dashboard read is { "data": { "id", "name", "can_change", "filter_words", "filter", "cards", "what_changed", "url" } }, with type, list_id and shared_with_team for a CRM one, or table for a table's. filter is the dashboard's filter as a query takes it, or null when some of it only the app can hold. Each card has id, title, size, settings (the card format above), words, screen_only_rules, and result or error. Send a card's settings back to a query as they are only when its screen_only_rules is 0. what_changed is { "text", "at", "by", "out_of_date" } or null. url is the address that opens the dashboard on startupcorners.com: /crm?view=<id>, or /files/doc/<id>?view=<id> for a table (null for a table kept only inside a page).

Working numbers out takes one of 60 chart requests a minute per key: both queries and reading one dashboard, here or over MCP. Lists and fields do not count. Past that, the answer is 429.

Webhooks

Method and address
Needs
What it does
GET /webhooks
webhooks:manage
Your webhooks that reach this startup.
POST /webhooks
webhooks:manage
A webhook for this startup from { "url": "https://...", "events": [...] }. The answer holds its signing secret, shown only once.
DELETE /webhooks/{id}
webhooks:manage
Removes it.
PATCH /webhooks/{id}
webhooks:manage
{ "paused": false } turns a paused webhook back on.

Events:

  • CRM: record.created, record.updated, record.deleted, entry.created, entry.updated, entry.moved, entry.deleted, note.created, form.submitted (form_id, record_id).
  • Tasks: task.created, task.updated (fields names what changed), task.completed, task.deleted, each with task_id. Only the startup's own tasks post.
  • Tables in Files: row.created, row.updated (columns names the changed columns), row.deleted, each with table_id (the id /tables/{table} takes) and row_id. A row posts only to webhooks whose maker can open its table.

Each post is signed in the StartupCorners-Signature header and looks like this:

{
  "id": "delivery id",
  "type": "entry.moved",
  "occurred_at": "2026-10-27T09:30:00.000Z",
  "entity": { "id": "...", "slug": "kumo-labs", "name": "Kumo Labs" },
  "workspace_id": "the same id as entity.id",
  "actor": { "type": "api_key", "id": "..." },
  "data": { "record_id": "...", "list_id": "...", "entry_id": "..." }
}

Errors

Keys, webhooks and connected apps are part of Plus: a key whose maker is not on Plus answers 403 plus_required, a connected app gets that reason as the error of each request, and webhooks do not post until the maker is on Plus again.

Errors look like { "error": { "code": "...", "message": "..." } }.

Status
Code
When
400
entity_required
The key reaches several startups and the address has no ?entity=. The answer lists them in entities.
400
invalid_request
The body or a query value is not valid.
401
missing_key, invalid_key
No key, or a wrong or revoked one.
401
key_owner_left
The key reaches no startup any more: its maker is no longer an owner or admin of any of them.
403
entity_not_allowed
The key does not reach that startup.
403
missing_scope
The key may not do this.
403
go_public_first
A course team's CRM opens once the team goes public.
404
not_found
The record, pipeline or object does not exist in that startup.
409
duplicate
The email or domain is on another record, given in existing_record_id.
410
gone
The deals object: deals are entries in the Customers list now. The message says where.
413
too_large
The request body is over 5 MB. Send fewer rows at a time.
422
invalid_value
A field or choice does not exist, or a value is wrong. The message names it.
422
read_only_column
A table cell of a CRM count or formula column was written. The answer names it in column.
429
rate_limited
More than 100 requests in 10 seconds, or more than 60 chart requests a minute. Wait the seconds in Retry-After.

AI tools (MCP)

POST https://startupcorners.com/api/mcp is an MCP server for Claude, Cursor and other AI tools, with the same key. Its tools: list_startups, describe_crm, search_records, get_record, upsert_record (with kind, and list and stage to put it in a type), update_record, list_pipelines, list_entries (with filter, tz and view), add_to_list, move_entry, remove_entry, add_note (with created_at), delete_note, with Manage fields and pipelines create_field, add_field_options and create_pipeline, for tables list_tables, read_table (with view), list_table_views, save_table_view, delete_table_view, add_table_rows, update_table_row, delete_table_row, create_table, change_table_columns, update_table and trash_table, for tasks list_tasks, get_task, create_task and update_task, and for dashboards, read only, list_chart_fields, chart, list_dashboards and get_dashboard with Read people, companies and deals, and chart_table and get_table_dashboards (with dashboard, that one's cards and numbers) with Read tables in Files. Each takes an optional entity, as the addresses above do. One request can carry at most 20 messages; a bigger batch is refused whole. remove_entry, delete_note, delete_table_row, delete_table_view and trash_table are marked as destructive, so AI tools that heed that ask you before they use them.

Signing in instead of a key (OAuth)

Apps that cannot send a key, like claude.ai's connectors, sign in. A call to /api/mcp without a token answers 401 with WWW-Authenticate: Bearer resource_metadata="https://startupcorners.com/.well-known/oauth-protected-resource/api/mcp". From there:

  • GET /.well-known/oauth-authorization-server lists the endpoints.
  • POST /api/oauth/register registers the app (RFC 7591): redirect_uris (https, or http on localhost) and client_name. Public clients only, with no secret.
  • /oauth/authorize is the page where the person signs in and ticks the startups and what the app may do. It needs response_type=code, code_challenge with code_challenge_method=S256, and state. scope may name records:read, records:write, lists:read, lists:write, notes:write, tables:read, tables:write, tasks:read, tasks:write and schema:write; webhooks are not offered.
  • POST /api/oauth/token swaps the code (single use, 10 minutes) and its code_verifier for an access token (1 hour) and a refresh token (60 days). Each refresh gives a new pair; the old refresh token stops working.

The access token is sent as Authorization: Bearer sc_oat_... and works like a key with the ticked scopes. People see and disconnect these apps in Settings > API & webhooks > Connected apps.

Did this answer your question?

Related

Send leads to your CRM with the APIAdd a form to your websiteSee your CRM and tables as charts