Provider REST API

Automation

Connect Claude to Apify

Find and run Apify Actors - ready-made scrapers and automations - and read the data they collect. Toolspoke puts 16 of its actions behind one MCP endpoint that Claude, Cursor, and Codex all speak.

Connection
Provider REST API
Authentication
API token
Actions exposed
16
What a call bills
Nothing
Adapter
Maintained by Toolspoke

Connected in three steps

  1. 1

    Install Apify

    Open the marketplace in your workspace, add Apify to the project your agents work in, and it appears on the gateway immediately.

  2. 2

    Connect the credential

    Authenticate with api token. Where to get one, and what it has to be able to reach, is the next section.

  3. 3

    Point your agent at the gateway

    Give your client one address, https://toolspoke.com/mcp. Claude Code takes it as a command, Claude and Claude Desktop add it as a custom connector, and Cursor, Codex and VS Code each read it from a config file of their own.

.mcp.json
{
  "mcpServers": {
    "toolspoke": {
      "type": "http",
      "url": "https://toolspoke.com/mcp"
    }
  }
}

One block covers every tool you have installed. Apify shows up in the client as soon as your policy allows it, and so does everything else you install later.

Where the address goes, per client

Claude Code

Run it in your project, then /mcp to sign in

claude mcp add --transport http toolspoke https://toolspoke.com/mcp
Claude and Claude Desktop

Settings, then Connectors, then Add custom connector

https://toolspoke.com/mcp
Cursor

~/.cursor/mcp.json, or .cursor/mcp.json for one project

{ "mcpServers": { "toolspoke": { "url": "https://toolspoke.com/mcp" } } }
Codex

~/.codex/config.toml

[mcp_servers.toolspoke]
url = "https://toolspoke.com/mcp"
VS Code

.vscode/mcp.json, or the MCP: Add Server command

{ "servers": { "toolspoke": { "type": "http", "url": "https://toolspoke.com/mcp" } } }

What Apify asks for

API token. You provide it once, when you install the connector. Toolspoke encrypts it at rest and decrypts it only for the length of a single call, and the gateway attaches it to the outbound request itself, so it is never part of the arguments an agent sends.

API tokenRequired
console.apify.com → Settings → API & Integrations → Personal API tokens. Copy the default token, or create a new one and scope it to the Actors and storages it may reach.
apify_api_…

What Claude can do in Apify

16 actions, each one declared and named by the connector rather than discovered at runtime. A workspace policy grants a person all of them, a hand-picked selection, everything on the read side, everything on the write side, or none.

Reads
12Reads
Writes
3Writes
Destructive
1Destructive

Reads

12

Fetches data and changes nothing.

  • search_store

    Search Apify Store for public Actors by keyword, e.g. "google maps" or "instagram profile". Returns each Actor's id, username, name, title, description, pricing and usage stats. Free. Use the `username~name` it returns as the actor_id for get_actor and run_actor.

  • list_actors

    List the Actors this account has created or used. Set `my` to list only the ones it owns.

  • get_actor

    Read one Actor: its title, description, versions, default run options, pricing and an example input. Read this before run_actor to see what input it expects.

  • list_runs

    List this account's Actor runs across all Actors, with id, Actor id, status, start and finish times and usage cost. Newest first when `desc` is set. This is the connection test: it fails when the token cannot read runs, not just when the token is wrong.

  • list_actor_runs

    List the runs of one Actor, newest first when `desc` is set.

  • get_run

    Read one run: its status, timings, usage cost, and the ids of its default dataset and key-value store. Set `waitForFinish` (up to 60 seconds) to wait for a running run instead of polling.

  • get_run_log

    Read a run's log as plain text. Use it to find out why a run failed. Logs can quote the pages the Actor scraped, so the payload is kept out of the audit log.

  • list_datasets

    List this account's datasets, with id, name, item count and dates. Unnamed datasets (the default dataset of each run) are left out unless `unnamed` is set.

  • get_dataset_items

    Read the items a run collected, as JSON. Take the dataset id from a run's defaultDatasetId. Hidden fields and empty items are left out. Page with `limit` and `offset`, and pick fields with `fields` to keep the answer small. The items are scraped content, so the payload is kept out of the audit log.

  • get_record

    Read one record from a key-value store, e.g. a run's OUTPUT or INPUT. Take the store id from a run's defaultKeyValueStoreId. The record can be anything the Actor saved, so the payload is kept out of the audit log.

  • list_tasks

    List this account's saved tasks - Actors with a stored input and options - with id, name and Actor id.

  • get_monthly_usage

    Read this account's usage and cost for one billing month, broken down by service and by day. Use it to check spend before starting a large run.

Writes

3

Creates or updates something on the other side.

  • run_actor

    Start an Actor run and return the run at once, with its id, status and defaultDatasetId. Classified write because a run spends the account's money. Cap it with `maxTotalChargeUsd` on pay-per-event Actors and `timeout` on the rest. Set `waitForFinish` (up to 60 seconds) to wait for a short run; otherwise poll get_run, then read the results with get_dataset_items. The input is often content the caller wrote, so it is kept out of the audit log.

  • run_actor_sync

    Run an Actor, wait for it to finish, and return the items it collected, in one call. Only for short runs: Apify returns 408 if the run takes more than 300 seconds, and the run keeps going. Use run_actor for anything longer. Classified write because a run spends money; cap it with `maxTotalChargeUsd` or `maxItems`. The items are scraped content, so the payload is kept out of the audit log, and so is the input.

  • run_task

    Start a run of a saved task with its stored input, and return the run at once. Classified write because a run spends money. `input` is merged over the task's stored input for this run only. Poll get_run, then read results with get_dataset_items.

Destructive

1

Deletes or permanently alters something. Worth granting on purpose.

  • abort_run

    Stop a starting or running run. Classified destructive because the run's remaining work is lost unless someone resurrects it later. Set `gracefully` to send the Actor a persistState event and force-stop it after 30 seconds, which is what makes a later resurrect useful. Does nothing to a run that has already finished.

What it will not do

Enforced by the gateway rather than left to convention, which is why each of these can be stated flatly.

It cannot call anything else
The 16 actions above are the whole of it. A call to any other name is refused before it reaches Apify rather than forwarded on, and connecting your account does not add to the list: it is fixed by the connector, not discovered at run time.
It reaches no further than your credential
Toolspoke holds no access to Apify of its own. Every call carries the credential you stored and nothing besides, so whatever that credential cannot reach, this connector cannot reach either.
It never hears from Apify
Nothing is pushed to it. There is no webhook, no subscription and no polling, so this connector cannot notice by itself that something changed in Apify. An agent has to ask.
It does not smooth over provider limits
Toolspoke does not retry, queue or back off around Apify's own rate limits. A call that Apify refuses comes back to the agent as a failed call.

Before you connect it

What can Claude do in Apify?

16 named actions: 12 that only read, 3 that write and 1 that delete or permanently alter something. They include search_store, list_actors and get_actor. Nothing outside that list is reachable: the connector declares each operation by name rather than proxying whatever an agent asks for.

What credentials does the Apify connector need?

API token. The connector asks for api token. Values are encrypted at rest and attached to the outbound request by the gateway, so they are never part of the arguments an agent sends and never reach the audit log.

Does the Apify connector work with Cursor and Codex, or only Claude?

Any client that speaks MCP, and every one of them gets the same 16 actions. There is a single address, https://toolspoke.com/mcp. Claude Code adds it with claude mcp add --transport http, Claude and Claude Desktop take it as a custom connector in settings, Cursor reads it from .cursor/mcp.json, Codex from ~/.codex/config.toml, and VS Code from .vscode/mcp.json. Each of them signs in to the gateway itself, so there is no key to paste.

What does the Apify connector not do?

The 16 actions above are the whole of it. A call to any other name is refused before it reaches Apify rather than forwarded on, and connecting your account does not add to the list: it is fixed by the connector, not discovered at run time. Toolspoke holds no access to Apify of its own. Every call carries the credential you stored and nothing besides, so whatever that credential cannot reach, this connector cannot reach either. Nothing is pushed to it. There is no webhook, no subscription and no polling, so this connector cannot notice by itself that something changed in Apify. An agent has to ask. Toolspoke does not retry, queue or back off around Apify's own rate limits. A call that Apify refuses comes back to the agent as a failed call.

Can I limit which actions an agent can call?

Yes, in two places. The project switches Apify's actions on and off one at a time, for everyone in the project at once, and the screen groups them by read, write and destructive so turning off everything that deletes is one click. An individual agent key can then be narrowed further, to particular toolkits in a project and to particular actions in a toolkit. Whatever it was granted, a key never reaches a project its owner cannot.

What gets recorded when an agent calls Apify?

Every attempt, with the agent that made it and the person that agent belongs to, the full request payload, the response payload, the status, the duration, and what the call cost in sandbox time and model tokens. Values whose key names a secret are masked out before the record is shown to anyone. An operation the connector marks as not retained never has its response body written at all, so the gateway keeps no second copy of what was read.