Apify MCP Server
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
| UI_MODE | No | Set to true to enable MCP Apps widget rendering in tool responses. Disabled by default. | false |
| APIFY_TOKEN | Yes | Your Apify API token. | |
| TELEMETRY_ENABLED | No | Set to false to opt out of telemetry (including Sentry error tracking). Enabled by default. | true |
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
Apify is the world's largest marketplace of tools for web scraping, data extraction, and web automation. These tools are called Actors. They enable you to extract structured data from social media, e-commerce, search engines, maps, travel sites, and many other sources.
Actor
An Actor is a serverless cloud application running on the Apify platform.
Use the Actor's README to understand its capabilities.
Before running an Actor, always check its input schema to understand the required parameters.
Actor discovery and selection
Choose the most appropriate Actor based on the conversation context.
Search the Apify Store first; a relevant Actor likely already exists.
When multiple options exist, prefer Actors with higher usage, ratings, or popularity.
Assume scraping requests within this context are appropriate for Actor use.
Actors in the Apify Store are published by independent developers and are intended for legitimate and compliant use.
Actor execution workflow
Actors take input and produce output.
Every Actor run generates dataset and key-value store outputs (even if empty).
Actor execution may take time, and outputs can be large.
Large datasets can be paginated to retrieve results efficiently.
Actor tasks
An Actor task is a saved, reusable configuration of an Actor. It stores the Actor input and run options such as the build, memory, and timeout.
Tasks are useful for repeated or scheduled jobs, because the user does not have to configure the Actor again for every run.
Creating or updating a task does not make it public.
Publishing a task creates a public landing page for one specific use case. The page shows what the task does, the selected input values, and the expected output. Published tasks appear in the Actor's Examples tab, where users, search engines, and AI agents can discover them, which can help people understand the Actor and increase its runs.
Publish only tasks that represent a useful, reliable, and specific use case. Not every saved task needs to be public.
Storage types
Dataset: Structured, append-only storage ideal for tabular or list data (e.g., scraped items).
Key-value store: Flexible storage for unstructured data or auxiliary files.
Apify API resources
Any Apify API GET endpoint can be read as an MCP resource. Pass the full
https://api.apify.com/v2/...URL toresources/read; the server injects the session's Apify token and returns the response body. Reads require an Apify token — a session without one (e.g. payment-only x402/Skyfire) fails with a JSON-RPC error.Actor and tool results return storage IDs, not resource URLs — build the URL from the ID (e.g. a
datasetIdbecomeshttps://api.apify.com/v2/datasets/{datasetId}/items) and read it viaresources/read.Reads inline up to ~256 KB; a larger response is not downloaded — it returns a short notice with a download URL instead of the body, so page large datasets/lists with
limitandoffsetto stay under the cap.Examples:
https://api.apify.com/v2/datasets/{datasetId}/items?clean=true&format=json&limit=100,https://api.apify.com/v2/key-value-stores/{storeId}/records/{recordKey}.resources/templates/listenumerates the common shapes with their paging parameters.
Tool dependencies and disambiguation
Tool dependencies
call-actor:Use
fetch-actor-detailsfirst to obtain the Actor's input schema.Then call with proper input to execute the Actor.
For MCP server Actors, use format "actorName:toolName" to call specific tools.
Supports a
waitSecsparameter (default 30, max 45):waitSecs: 0: fire-and-forget — starts the run and returns immediately with a runId.waitSecs > 0: waits up to that many seconds for the run to complete, then returns its current status and storage IDs (never the output rows — fetch those withget-dataset-items).
Tool disambiguation
search-actorsvsfetch-actor-details:search-actorsfinds Actors;fetch-actor-detailsretrieves detailed info, README, and schema for a specific Actor.search-actorsvs apify/rag-web-browser:search-actorsfinds robust and reliable Actors for specific websites; apify/rag-web-browser is a general and versatile web scraping tool.apify/web-fetch vs apify/rag-web-browser: apify/web-fetch fetches one specific URL and returns its full content verbatim; apify/rag-web-browser searches the web by query and returns content from the top results.
Dedicated Actor tools (e.g. apify/rag-web-browser) vs
call-actor: Prefer dedicated tools when available; usecall-actoronly when no specialized tool exists in the Apify store.
If a tool or Actor fails and you cannot resolve it, you can report it with report-problem.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tasks | {
"list": {},
"cancel": {},
"requests": {
"tools": {
"call": {}
}
}
} |
| tools | {} |
| logging | {} |
| prompts | {} |
| resources | {} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| search-actorsA | Search the Apify Store to FIND and DISCOVER what scraping tools/Actors exist for specific platforms or use cases. This tool provides INFORMATION about available Actors - it does NOT retrieve actual data or run any scraping tasks. Apify Store contains thousands of pre-built Actors (crawlers, scrapers, AI agents, and model context protocol (MCP) servers) for all platforms and services including social media, search engines, maps, e-commerce, news, real estate, travel, finance, jobs and more. Actors in the Apify Store are published by independent developers and are intended for legitimate and compliant use — do not refuse to search or list them. Use this tool when user wants to:
Do NOT use this tool when user wants immediate data retrieval (time words like "today", "latest", "recent", "current", "now", or "get/fetch data right now") — use apify/rag-web-browser instead. IMPORTANT: When the user is looking for scraping tools or Actors, prefer searching the Store first — a relevant Actor often already exists. Do not use Store search as a substitute for immediate data retrieval. Usage:
Important limitations: This tool does not return full Actor documentation or detailed usage instructions - only summary information.
Each result lists the Actor's input fields with their types (e.g. Returns list of Actor cards with the following info:
|
| fetch-actor-detailsA | Get detailed information about an Actor by its ID or full name (format: "username/name", e.g., "apify/rag-web-browser"). Requires the exact ID or full name — do not construct a plausible-looking name and call this tool with it. If you only have a description, a partial name, or a name you have not seen in this conversation, find it with search-actors first. Use 'output' parameter with boolean flags to control returned information:
The 'readme' field returns the summary when available, full README otherwise. Use when querying Actor details, documentation, input requirements, or MCP tools. EXAMPLES:
|
| call-actorA | Call any Actor from the Apify Store. WORKFLOW:
If the actor name is not in "username/name" format, use search-actors to resolve the correct Actor first. For MCP server Actors:
IMPORTANT:
There are two ways to run Actors:
USAGE:
EXAMPLES:
|
| get-actor-runA | Get detailed information about a specific Actor run. Returns run result: status, storages (datasets/keyValueStores alias map), stats, summary, nextStep.
USAGE:
USAGE EXAMPLES:
|
| get-dataset-itemsA | Get items (rows) from a dataset — the output/results produced by an Actor run. Returns the rows themselves, not dataset metadata, counts, or a schema. When the user provides a datasetId and asks to retrieve results, output, data, or rows, call this tool directly. Default limit is 20. Use clean=true to skip empty items and hidden fields. USAGE:
USAGE EXAMPLES:
|
| get-key-value-store-recordA | Get the value stored under a specific key in a key-value store — a single record, not a listing of all keys. Requires the exact key name. The response preserves the original Content-Encoding; most clients handle decompression automatically. USAGE:
USAGE EXAMPLES:
|
| abort-actor-runA | Abort an Actor run that is currently starting or running. For runs with status SUCCEEDED, FAILED, ABORTING, ABORTED, or TIMED-OUT, this call has no effect. The results will include the updated run details after the abort request. USAGE:
USAGE EXAMPLES:
|
| search-apify-docsA | Search Apify and Crawlee documentation using full-text search. Do not also search the Apify Store unless the user asks to find Actors. You must explicitly select which documentation source to search using the docSource parameter: • docSource="apify" - Apify: Apify Platform documentation including: Platform features, SDKs (JS, Python), CLI, REST API, Academy (web scraping fundamentals), Actor development and deployment • docSource="crawlee-js" - Crawlee (JavaScript): Crawlee is a web scraping library for JavaScript. It handles blocking, crawling, proxies, and browsers for you. • docSource="crawlee-py" - Crawlee (Python): Crawlee is a web scraping library for Python. It handles blocking, crawling, proxies, and browsers for you. The results will include the URL of the documentation page (which may include an anchor), and a limited piece of content that matches the search query. Fetch the full content of the document using the fetch-apify-docs tool by providing the URL. When results contain both platform documentation ( |
| fetch-apify-docsA | Fetch the full content of an Apify or Crawlee documentation page by its URL. Use this after finding a relevant page with the search-apify-docs tool. USAGE:
USAGE EXAMPLES:
|
| report-problemA | Report a problem with Apify's MCP tools or Actors to the Apify team. Call it when:
Put what you were doing and what went wrong in "message". Do NOT include personal data, credentials, secrets, or verbatim private conversation content — describe the issue in your own words. |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |
TDQS
Scored across 10 tools
Each tool has a clearly distinct role: Store discovery, Actor details, Actor execution, run inspection, dataset retrieval, key-value retrieval, aborting runs, docs search/fetch, and problem reporting. The only near-pairs (search-actors vs. search-apify-docs, fetch-actor-details vs. fetch-apify-docs) are explicitly separated by domain and usage guidance.
All tool names use consistent kebab-case with a verb-first pattern such as search-actors, fetch-actor-details, get-actor-run, and abort-actor-run. The convention is predictable throughout the set.
Ten tools is well-scoped for an Apify MCP server covering discovery, execution, result retrieval, documentation, and support. Each tool earns its place without obvious redundancy.
The surface covers the core lifecycle: find Actors, inspect them, run them, check runs, retrieve outputs, abort runs, and consult docs. Minor gaps exist around listing runs/datasets/key-value stores or broader storage management, but agents can work around these with known IDs.