Apify MCP server

Apify MCP server

Connect your agent to the largest marketplace of tools for AI.

The official Apify Model Context Protocol (MCP) server gives AI agents web scraping, data extraction, and browser automation through thousands of ready-made Actors from Apify Store, at https://mcp.apify.com.

Apify is the marketplace of ready-to-run tools for AI agents. One connection to the Apify MCP server gives your agent thousands of tools to choose from, for jobs like web fetch, SERP monitoring, lead generation and enrichment, and pulling data from e-commerce sites and social media. The server loads only what each task needs.

Your agent searches Apify Store, checks an Actor's input and pricing, runs it, and reads the structured results, so you don't install a separate MCP server for every site. Connect to the hosted server with OAuth, or run it locally over stdio with the @apify/actors-mcp-server npm package.

Contents

• Quickstart
• Set up your client
• Remote (hosted) or local MCP server
• How an agent uses Apify Actors
• Tools, resources, and prompts
• Choose which tools load
• UI mode configuration
• Example prompts
• Pricing and limits
• Telemetry
• Troubleshooting and limitations
• FAQ
• Development
• Contributing
• Privacy and license
• Learn more

🚀 Quickstart

1. Open the MCP configurator, pick your client, and choose the tools you want.
2. Copy the generated configuration, deeplink, or command into your client.
3. Sign in to Apify in the browser window that opens. If you don't have an account, you can create a free one there.

The hosted endpoint is https://mcp.apify.com. If your client can't use OAuth, send your Apify API token in an Authorization: Bearer <APIFY_TOKEN> header instead. Treat the token like a password and keep it out of repositories.

Using a coding agent such as Claude Code, Codex, Cursor, or GitHub Copilot? An official Apify plugin installs this MCP server together with Apify agent skills in one step.

🤖 Set up your client

The configurator generates the exact setup for each supported client, including Claude Code, ChatGPT, Cursor, VS Code, GitHub Copilot CLI, Claude, Claude Desktop, Codex, OpenCode, Kiro, and more. The snippets below cover the most common cases.

claude mcp add apify "https://mcp.apify.com" -t http

Claude Code opens the Apify sign-in page the first time it uses the server. To install the Apify plugin with Apify agent skills instead, run /plugin marketplace add apify/apify-claude-code-plugin, then /plugin install apify@apify and /reload-plugins.

1. Open ChatGPT Plugins, select +, then Add custom MCP server.
2. Name it Apify, enter https://mcp.apify.com as the server URL, and choose OAuth authentication.
3. Review the risk warning, select I understand and want to continue, then Create as a plugin.
4. Sign in with Apify, review the tools, and install the plugin. No API token is needed.
5. Start a new conversation, type @, and select Apify.

In Business, Enterprise, and Edu workspaces, an admin or owner may need to create or publish the plugin. If the option is missing, ask your workspace admin. When the server's tools change, open the plugin and select Refresh.

The ChatGPT desktop app uses local MCP configuration shared with Codex instead: go to Settings > MCP servers > Add server, choose Streamable HTTP, and enter https://mcp.apify.com. See OpenAI's custom MCP server guide.

Use the one-click install link from the configurator, or let the Apify CLI write the configuration, including your API token:

apify mcp install cursor

The same command works for claude-code, vscode, codex, kiro, and antigravity.

Use the one-click install link from the configurator, run apify mcp install vscode, or add https://mcp.apify.com as an HTTP server in your MCP configuration:

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

Apify is available as a Claude connector. Open Settings > Connectors, find Apify in the connector directory, and connect it. You can also select Add custom connector, name it Apify, and enter https://mcp.apify.com as the remote MCP server URL. Sign in with Apify when prompted. The same connector works on Claude.ai and in Claude Desktop. See the Claude guide.

Most clients that support remote servers and OAuth accept a configuration like this:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}

Requires Node.js 22 or later.

{
  "mcpServers": {
    "actors-mcp-server": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}

If you've run apify login, the server can also read the token saved by the Apify CLI. Run npx @apify/actors-mcp-server --help for all options.

The server is also listed in the Docker MCP catalog, and each release ships an MCP bundle file (apify-mcp-server.mcpb) for one-click installation in clients that support it.

Remote (hosted) or local MCP server

The hosted remote MCP server with OAuth is the recommended option. Use the local server when you want to run the MCP process on your own machine; Actors still run and store their results on the Apify platform in both modes. If your client supports only stdio, you can also bridge it to the hosted server with mcp-remote: npx mcp-remote https://mcp.apify.com.

	Hosted (https://mcp.apify.com)	Local (npx @apify/actors-mcp-server)
Transport	Streamable HTTP	stdio
Authentication	OAuth or Bearer token	APIFY_TOKEN environment variable or Apify CLI login
Output schemas inferred for Actor results	Yes	No
Tool selection	tools URL parameter	--tools flag or TOOLS environment variable
Updates	Always the latest server	The npm version you install

How an agent uses Apify Actors

Actors are serverless programs on the Apify platform. Each one does a specific job, like scraping Google Maps, crawling a website for RAG, or collecting social media posts. The MCP server turns Actors into tools an agent can find and call without you configuring each one in advance.

A typical task follows four steps:

1. search-actors finds candidate Actors in Apify Store for the task.
2. fetch-actor-details returns the Actor's input schema, README, and pricing, plus its output schema on request.
3. call-actor starts the run and waits for it to finish, 30 seconds by default and up to 45. It returns the run status and storage IDs; the scraped items stay in the run's dataset.
4. get-dataset-items reads the results from the run's dataset, with limit and offset for pagination.

The server adds get-dataset-items, get-key-value-store-record, get-actor-run, and abort-actor-run whenever call-actor or an Actor tool is loaded, so the agent can always read results and check on long runs that outlast the wait.

You can also expose a specific Actor as its own tool, for example apify/instagram-scraper. The server builds the tool's parameters from the Actor's input schema, so the agent knows exactly what to pass. A Server Actor with an API schema, such as apify/web-fetch, apify/web-search, or apify/rag-web-browser, gets a tool that sends one HTTP request to its API instead.

Actors that run their own MCP server. Some Actors are MCP servers themselves. fetch-actor-mcp-tool-list lists their tools, and call-actor-mcp-tool calls one. When such an Actor is loaded as a tool source and has no API schema, its tools are exposed under names in the form username--actor-name--tool-name; an Actor with an API schema, such as apify/web-search, gets its server tool instead, and call-actor-mcp-tool reaches its MCP tools. Apify Store also lists MCP-related Actors from independent creators; those are separate products with their own READMEs and pricing.

🛠️ Tools, resources, and prompts

Any Actor can be a tool, and agents discover new ones as they work. By default, the server loads the actors and docs categories, two Actor tools (Web Search and Web Fetch), and report-problem. Everything else is opt-in by category or by tool name.

Helper tools

Besides Actor tools, the server provides helper tools for the Apify platform:

• Actors: search Apify Store, list the Actors in your account, view their details, call tools on Actors that run MCP servers, send requests to Server Actors, and delete your own Actors.
• Documentation: search the Apify and Crawlee docs and fetch pages as context.
• Runs and storage: list runs, inspect them, read their logs, and read datasets and key-value stores.
• Tasks and schedules: manage saved Actor tasks and their public landing pages, and schedules that run Actors and tasks automatically.
• Builds and versions: build Actors, read build logs, and create, read, change, copy, and delete versions from files.
• Apify API: search the API reference, inspect an operation, and send requests to read or change data.

Available tools

Legend for the Enabled by default column:

• ✅ In the default tool set.
• ⚡ Added automatically when call-actor, an Actor tool, or get-actor-run is loaded, which is true in the default configuration.
• ✅¹ Served by default only when telemetry is on and the client name doesn't contain claude, anthropic, or local-agent-mode. Select it explicitly with tools=report-problem or tools=dev to serve it to any client; telemetry still has to be on.

Tool name	Category	Description	Enabled by default
search-actors	actors	Search for Actors in Apify Store.	✅
fetch-actor-details	actors	Get an Actor's input schema, README (summary when available, full otherwise), pricing, and a Server Actor's HTTP operations. The output schema is opt-in.	✅
call-actor	actors	Run an Actor and return its run status and storage IDs. Use fetch-actor-details first to get the input schema.	✅
fetch-actor-mcp-tool-list	actors	List the tools of an Actor that runs an MCP server, with their schemas, annotations, and metadata.	✅
call-actor-mcp-tool	actors	Call one tool on an Actor's MCP server and return its result.	✅
send-server-actor-request	actors	Send one HTTP request to a Server Actor's API, as documented by its API schema, and return the response.	✅
get-actor-run	runs	Get details about an Actor run.	⚡
get-dataset-items	storage	Read items from a dataset, with filtering and pagination.	⚡
get-key-value-store-record	storage	Get the value stored under a key in a key-value store.	⚡
abort-actor-run	runs	Abort a running Actor run, optionally gracefully.	⚡
search-apify-docs	docs	Search the Apify and Crawlee documentation for relevant pages.	✅
fetch-apify-docs	docs	Fetch the full content of a documentation page by its URL.	✅
apify--web-search	Actor (see Choose which tools load)	Search the web and return one page of results: titles, URLs, and snippets.	✅
apify--web-fetch	Actor (see Choose which tools load)	Fetch a URL and return its content as Markdown, text, HTML, or other formats.	✅
report-problem	dev	Report a problem with an Apify tool or Actor to the Apify team.	✅¹
apify--rag-web-browser	Actor (see Choose which tools load)	Search the web and return the content of the top results.
get-actor-list	none (select by name: tools=get-actor-list)	List the Actors you own and those shared with you, including private ones.
delete-actor	none (select by name: tools=delete-actor)	Delete an Actor from your account permanently. Public Actors must be unpublished first.
get-actor-run-list	runs	List Actor runs, filtered by Actor and status.
get-actor-run-log	runs	Read the log of an Actor run.
get-dataset	storage	Get metadata about a dataset.
get-dataset-schema	storage	Generate a JSON schema from dataset items.
get-dataset-list	storage	List the datasets in your account.
get-key-value-store	storage	Get metadata about a key-value store.
get-key-value-store-keys	storage	List the keys in a key-value store.
get-key-value-store-list	storage	List the key-value stores in your account.
create-actor-task	tasks	Create a saved Actor task (a named, reusable Actor configuration).
get-actor-task	tasks	Get a saved Actor task, its publication state, and its public display configuration.
update-actor-task	tasks	Update a task's input, run options, or public display configuration.
publish-actor-task	tasks	Publish a task on its public landing page.
unpublish-actor-task	tasks	Unpublish a task from its public landing page.
create-schedule	schedules	Create a schedule that runs Actors or tasks on a cron expression.
get-schedule	schedules	Get a schedule, its cron expression, state, and the actions it runs.
update-schedule	schedules	Update a schedule's cron expression, time zone, enabled state, or actions.
delete-schedule	schedules	Delete a schedule.
build-actor	builds	Build an Actor version and wait a bounded time for the build to finish.
get-actor-build	builds	Get the status of an Actor build.
get-actor-build-list	builds	List the account's builds, or one Actor's, in every status, newest first.
get-actor-build-log	builds	Read the log of an Actor build.
get-actor-version	versions	Get an Actor version's file listing with hashes, plus the content of the files you ask for.
create-actor	versions	Create a private Actor in your account from files, optionally starting a build.
update-actor-version	versions	Write, edit, or delete files of an Actor version in one all-or-nothing write.
create-actor-version	versions	Add a version to an Actor, from files or as a copy of another version, optionally starting a build.
delete-actor-version	versions	Delete an Actor version. Its builds and their tags stay.
apify-api-search	api	Search the Apify API reference by keywords. Returns each operation's method, path, and docs page.
apify-api-details	api	Get the parameters and request body schema of the Apify API operations on a path.
apify-api-read	api	Send a GET request to an Apify API path, like apify api in the Apify CLI. It refuses GETs to the synchronous run endpoints, which start a paid run.
apify-api-write	api	Send a POST, PUT, PATCH, or DELETE request with a JSON body to any Apify API path, like apify api in the Apify CLI.

The tasks category manages saved Actor tasks. It is unrelated to the MCP Tasks protocol. The tool reference has full descriptions of each tool.

Tool annotations

Every tool carries a title, a readOnlyHint, and an openWorldHint. readOnlyHint is true for tools that only read data. Actor tools get it only for Apify-maintained Actors with limited permissions and no inputs that accept secrets, writable storage, an MCP connector, or code; other Actor tools are marked destructive. openWorldHint is true for tools that reach outside the Apify platform, such as call-actor, and false for platform-only tools.

Prompts and resources

No prompts are registered yet, so prompts/list returns an empty list. resources/read accepts any Apify API GET URL (https://api.apify.com/v2/...) and returns the response body using the session's Apify token, inlined up to 256 KB. Your data isn't enumerated in resources/list; resources/templates/list lists the common shapes with their paging parameters.

Choose which tools load

The tools parameter takes categories, tool names, and Actor names, separated by commas. When you set it, the defaults are dropped and only what you list is loaded, plus the ⚡ run and storage tools whenever the list includes call-actor or an Actor. The easiest way to build a selection is the configurator.

Hosted server:

https://mcp.apify.com?tools=actors,docs,apify/web-search,apify/web-fetch

Local server:

npx @apify/actors-mcp-server --tools actors,docs,apify/web-search,apify/web-fetch

To give an agent a single Actor, list only that Actor. The agent gets its tool plus the four ⚡ tools it needs to read the results:

https://mcp.apify.com?tools=apify/instagram-scraper

Pin your tools in production. The default tool set can change between versions. Set tools explicitly if you need a stable interface.

• apify/web-search replaced apify/rag-web-browser in the default tools. To keep apify--rag-web-browser, add apify/rag-web-browser to your tools list, or set tools=actors,docs,apify/rag-web-browser,apify/web-fetch for the previous default categories and Actors.
• The actors URL parameter and --actors flag still work. They're merged into tools, so ?actors=apify/web-fetch equals ?tools=apify/web-fetch.
• enableAddingActors, enable-adding-actors, and enableActorAutoLoading were removed and are ignored. Dynamic Actor calls come from call-actor, which the default actors category includes.
• The selectors add-actor, experimental, and preview are retired and load nothing. Use call-actor or the actors category.
• get-actor-log was renamed to get-actor-run-log, and the source category to versions. The old names load nothing.
• call-actor no longer calls tools on MCP server Actors: the actorName:toolName form is rejected. Use call-actor-mcp-tool with actor, tool, and arguments. call-actor still starts a run of an MCP server Actor that has an input schema; one without is refused. A selection that names call-actor alone needs call-actor-mcp-tool added.
• fetch-actor-details no longer lists an MCP server Actor's tools, and output.mcpTools is ignored. Use fetch-actor-mcp-tool-list, which returns the definitions in structuredContent.tools. A selection that names fetch-actor-details alone needs fetch-actor-mcp-tool-list added.
• A selected Actor with an API schema (a Server Actor) gets a tool that sends one HTTP request to its API, with method, path, and query arguments, instead of a tool that starts a run. If the Actor is also an MCP server, the selection no longer loads its MCP tools: use call-actor-mcp-tool. call-actor still starts runs of the Actor when it has an input schema. A selected apify/rag-web-browser is served this way too, with GET /search.
• apify--web-fetch sends one HTTP request to the Web Fetch Actor's API instead of starting a run, and returns the HTTP response. Its arguments are method, path, query and, for POST /, body, for example {"method": "GET", "path": "/", "query": {"url": "https://example.com", "formats": ["markdown", "links"]}}.
• apify--web-search sends one HTTP request to the Web Search Actor's API instead of starting a run, and returns the HTTP response. Its arguments are method, path, query and, for POST /, body, for example {"method": "GET", "path": "/", "query": {"query": "AI agent payment protocols", "maxResults": 5}}. call-actor still starts runs of the Actor, and call-actor-mcp-tool calls its search MCP tool.