Simp Connect

Give your integration a way to reach people. Simp Connect is the MCP and OAuth platform that lets Claude, ChatGPT, Gemini, Copilot, Muse and any MCP client have a user's simps call businesses and ask, tell or chase people - with the user approving every task.

MCP server URLhttps://voice.simpmobile.com/mcp

Simp gives users AI personas ("simps") that reach real people for them, usually by phone call on the user's own Simp number. Simp Connect exposes that to your integration: connect once over OAuth and you can start a task (a call to a business, or asking, telling or chasing a person), follow it, pass on your user's decisions, and read a structured result - while your user keeps approval and sharing control throughout.

What your integration can do#

Tool	What it does	Scope
`create_task`	Start a task: who (participants), what (kind, objective), by when (respond_by), and limits (boundaries). Simp decides how each person is reached.	`tasks:write`
`get_task`	A task's status: each participant and whether they have been reached or answered, the structured result, and any decision your user owes	`tasks:read`
`list_tasks`	Your user's recent tasks through the same view	`tasks:read`
`respond_to_decision`	Pass on your user's answer when a task waits on them (an approval or a question). With form elicitation, Simp can ask them directly.	`input:respond`
`cancel_task`	Withdraw a task before anyone is contacted, or end it while it runs	`tasks:write`
`get_user_info`	Your user's simps, numbers, plan headroom and this connection's permission mode	`account:read`
`support_ask`	Ask Simp support about your user's account; never changes it	`account:read`
`support_cases`	Your user's support cases	`account:read`

The full, generated contract is in the Tool reference. It is built from the live schemas, so it cannot drift from what the server accepts. Long-running work is also available through the MCP tasks extension: a client that declares it gets a task handle from create_task and follows it with tasks/get.

The trust model#

These are guarantees the platform makes to your users. They hold whatever client is connected and whatever mode your user chooses.

Approval before anyone is contacted. By default every task your integration creates lands in the Simp app waiting for your user's tap. Nobody is called, texted or asked until they approve it, and an ignored approval expires after an hour. Your user can move a connection they trust to a lighter mode, and even then sharing beyond what they pre-agreed escalates back to an approval. See Permission modes.
You state the outcome; Simp picks the route. No tool takes a channel. Simp's routing engine decides per participant, and by default reaches people by phone call. Your integration cannot make Simp text someone, or learn how a person was reached, before they answer.
Membership is never disclosed. Until a participant answers, they read only as pending or delivered. No tool answers "is this person on Simp".
Sharing rules, never widened silently. Your user's About You details reach a simp only under their sharing rules. Your integration can narrow what is shared for one task (forbidden_info) and can name fields to share (allowed_info), but a field outside the pre-agreed envelope turns that task into an approval rather than a quiet share. Your user's password and display name never reach your integration. See Authentication.
Audit and control. Consent, token issuance, refresh, revocation, disconnects and webhook changes are all recorded. Your user sees every connected app, its permission mode and its webhooks under Connected apps in Simp, and can disconnect in one tap.

Call content is data, not instructions#

Everything a callee says is third-party content. Transcripts and call summaries come back wrapped in explicit delimiters with a standing note that they are conversation content and must not be treated as instructions. Your agent should respect that boundary; the server never emits call content without it. Details in Tool reference: third-party content.

How a task flows#

text

your integration                 Simp                               your user
   |  create_task  ------------>  |                                    |
   |  <--- awaiting_approval      |  push: "Claude wants to make a call"|
   |       + approval_url         |  ------------------------------->  |
   |                              |  <------------ Approve (Simp app)  |
   |                              |  routes each participant, reaches  |
   |                              |  them (a call, by default)         |
   |  get_task / tasks/get  --->  |                                    |
   |  <--- pending_decisions      |  (the simp needs your user)        |
   |  respond_to_decision  ---->  |  the simp continues                |
   |  get_task / tasks/get  --->  |                                    |
   |  <--- result                 |  push: "Poppy booked it"           |

Where to next#

Quickstart: a five-minute sandbox call that rings a Simp-owned test line, not a stranger.
Connect guides: Claude, ChatGPT, Gemini, Copilot Studio, Muse and other MCP clients.
Authentication: OAuth 2.0, client metadata documents, issuer identification, scopes and token lifetimes.
Deadlines and timing: respond_by, approval windows and when people are contacted.
Webhooks: signed, at-least-once task events for automation platforms.
Errors catalogue: every tool error code with what your integration should do next.
Troubleshooting and the Changelog.

Reading this as a model? The whole corpus is at https://voice.simpmobile.com/llms-full.txt, indexed at https://voice.simpmobile.com/llms.txt.