Apify MCP connector

1. Install the SDK

   Node.js

   npm install @scalekit-sdk/node

   Python

   pip install scalekit

   Full SDK reference: Node.js | Python

2. Set your credentials

   Add your Scalekit credentials to your .env file. Find values in app.scalekit.com > Developers > API Credentials.

   .env

   SCALEKIT_ENVIRONMENT_URL=<your-environment-url>
   SCALEKIT_CLIENT_ID=<your-client-id>
   SCALEKIT_CLIENT_SECRET=<your-client-secret>

3. Set up the connector

   Register your Apify MCP credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment.

   Dashboard setup steps

   Register your Apify API token with Scalekit so it can authenticate and proxy Actor requests on behalf of your users. Unlike OAuth connectors, Apify MCP uses API token authentication — there is no redirect URI or OAuth flow.

   1. Get an Apify API token

      • Go to console.apify.com and sign in or create a free account.

      • In the left sidebar, click your avatar → Settings → API & Integrations → API tokens.

      • Click + Create new token. Give it a name (e.g., Agent Auth) and click Create token.

      • Copy the token immediately — it will not be shown again.

   2. Create a connection in Scalekit

      • In Scalekit dashboard, go to AgentKit > Connections. Find Apify MCP and click Create.

      • Note the Connection name — you will use this as connection_name in your code (e.g., apifymcp).

   3. Add a connected account

      Connected accounts link a specific user identifier in your system to an Apify API token. Add them via the dashboard for testing, or via the Scalekit API in production.

      Via dashboard (for testing)

      • Open the connection you created and click the Connected Accounts tab → Add account.

      • Fill in:

        • Your User’s ID — a unique identifier for this user in your system (e.g., user_123)
        • Apify Token — the token you copied in step 1

      • Click Save.

      Via API (for production)

      Node.js

      await scalekit.actions.upsertConnectedAccount({
        connectionName: 'apifymcp',
        identifier: 'user_123',       // your user's unique ID
        credentials: { token: 'apify_api_...' },
      });

      Python

      scalekit_client.actions.upsert_connected_account(
          connection_name="apifymcp",
          identifier="user_123",
          credentials={"token": "apify_api_..."}
      )

4. Make your first call

   Node.js

   quickstart.ts

   import { ScalekitClient } from '@scalekit-sdk/node'
   import 'dotenv/config'
   
   const scalekit = new ScalekitClient(
     process.env.SCALEKIT_ENV_URL,
     process.env.SCALEKIT_CLIENT_ID,
     process.env.SCALEKIT_CLIENT_SECRET,
   )
   const actions = scalekit.actions
   
   const connector = 'apifymcp'
   const identifier = 'user_123'
   
   // Make your first call
   const result = await actions.executeTool({
     connector,
     identifier,
     toolName: 'apifymcp_search_actors',
     toolInput: {},
   })
   console.log(result)

   Python

   quickstart.py

   import os
   from scalekit.client import ScalekitClient
   from dotenv import load_dotenv
   load_dotenv()
   
   scalekit_client = ScalekitClient(
       env_url=os.getenv("SCALEKIT_ENV_URL"),
       client_id=os.getenv("SCALEKIT_CLIENT_ID"),
       client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"),
   )
   actions = scalekit_client.actions
   
   connection_name = "apifymcp"
   identifier = "user_123"
   
   # Make your first call
   result = actions.execute_tool(
       tool_input={},
       tool_name="apifymcp_search_actors",
       connection_name=connection_name,
       identifier=identifier,
   )
   print(result)

What you can do

Connect this agent connector to let your agent:

• Get key value store record, dataset items, actor run — Retrieve a record (JSON, text, or binary) from a key-value store by its key
• Run abort actor — Abort an Actor run that is currently starting or running
• Fetch actor details, apify docs — Get detailed information about an Actor by its ID or full name (format: ‘username/name’, e.g
• Search actors, apify docs — Search the Apify Store to FIND and DISCOVER what scraping tools/Actors exist for specific platforms or use cases
• Actor call — Call any Actor from the Apify Store
• Browser rag web — Web browser for AI agents and RAG pipelines

Common workflows

Tool calling

• Use apifymcp_search_actors to discover Actors for a specific platform or use case before deciding which to run.
• Use apifymcp_fetch_actor_details to retrieve an Actor’s input schema before calling it — always pass output: { inputSchema: true } to keep the response concise.
• Use apifymcp_call_actor to run an Actor synchronously, or with async: true for long-running tasks.
• Use apifymcp_get_actor_run to poll the status of an async run, and apifymcp_get_actor_output to retrieve results once complete.
• Use apifymcp_rag_web_browser when you need real-time web content for LLM grounding — it returns clean Markdown from the top search result pages.

Node.js

const toolResponse = await actions.executeTool({
  connector: 'apifymcp',
  identifier: 'user_123',
  toolName: 'apifymcp_fetch_actor_details',
  toolInput: {
    actor: 'apify/web-scraper',
  },
});
console.log('Actor details:', toolResponse.data);

Python

tool_response = actions.execute_tool(
    connection_name='apifymcp',
    identifier='user_123',
    tool_name='apifymcp_fetch_actor_details',
    tool_input={
        "actor": "apify/web-scraper",
    },
)
print("Actor details:", tool_response)

Tool list

Use the exact tool names from the Tool list below when you call execute_tool. If you’re not sure which name to use, list the tools available for the current user first.

apifymcp_abort_actor_run # Abort an Actor run that is currently starting or running. Has no effect on runs that are already finished, failed, or timed out. 2 params ▾

Abort an Actor run that is currently starting or running. Has no effect on runs that are already finished, failed, or timed out.

Name Type Required Description

runId string required The ID of the Actor run to abort.

gracefully boolean optional If true, the Actor run will abort gracefully with a 30-second timeout.

apifymcp_call_actor # Call any Actor from the Apify Store. By default waits for completion and returns results with a dataset preview. Use async mode to start a run in the background and get a runId immediately. Workflow: 1. Use apifymcp_fetch_actor_details with output: {"inputSchema": true} to get the Actor's exact input schema 2. Call this tool with the actor name and input matching that schema exactly 3. Use apifymcp_get_actor_output with the returned datasetId to fetch full results if needed For MCP server Actors, use format 'actorName:toolName' (e.g. 'apify/actors-mcp-server:fetch-apify-docs'). Use dedicated Actor tools (e.g. apifymcp_rag_web_browser) when available instead of this tool. When NOT to use: - You don't know the Actor's input schema — use apifymcp_fetch_actor_details first 4 params ▾

Call any Actor from the Apify Store. By default waits for completion and returns results with a dataset preview. Use async mode to start a run in the background and get a runId immediately. Workflow: 1. Use apifymcp_fetch_actor_details with output: {"inputSchema": true} to get the Actor's exact input schema 2. Call this tool with the actor name and input matching that schema exactly 3. Use apifymcp_get_actor_output with the returned datasetId to fetch full results if needed For MCP server Actors, use format 'actorName:toolName' (e.g. 'apify/actors-mcp-server:fetch-apify-docs'). Use dedicated Actor tools (e.g. apifymcp_rag_web_browser) when available instead of this tool. When NOT to use: - You don't know the Actor's input schema — use apifymcp_fetch_actor_details first

Name Type Required Description

actor string required Actor ID or full name in 'username/name' format (e.g. 'apify/rag-web-browser'). For MCP server Actors use 'actorName:toolName' format.

input object required Input JSON to pass to the Actor. Must match the Actor's input schema exactly — use apifymcp_fetch_actor_details with output: {"inputSchema": true} first to get the required fields and types.

callOptions object optional Optional run configuration options

waitSecs integer optional Seconds to wait for completion (0–45, default 30). Returns with current run status if not terminal within waitSecs.

apifymcp_fetch_actor_details # Get detailed information about an Actor by its ID or full name (format: 'username/name', e.g. 'apify/rag-web-browser'). WARNING: Omitting the 'output' parameter returns ALL fields including the full README, which can be extremely token-heavy. Always pass 'output' with only the fields you need. To get the input schema before calling an Actor, use: {"inputSchema": true}. When to use: - You need an Actor's input schema before calling it — use output: {"inputSchema": true} - User wants details about a specific Actor (pricing, description, README) - You need to list MCP tools provided by an MCP server Actor — use output: {"mcpTools": true} When NOT to use: - You already have the input schema and are ready to run — use apifymcp_call_actor directly 2 params ▾

Get detailed information about an Actor by its ID or full name (format: 'username/name', e.g. 'apify/rag-web-browser'). WARNING: Omitting the 'output' parameter returns ALL fields including the full README, which can be extremely token-heavy. Always pass 'output' with only the fields you need. To get the input schema before calling an Actor, use: {"inputSchema": true}. When to use: - You need an Actor's input schema before calling it — use output: {"inputSchema": true} - User wants details about a specific Actor (pricing, description, README) - You need to list MCP tools provided by an MCP server Actor — use output: {"mcpTools": true} When NOT to use: - You already have the input schema and are ready to run — use apifymcp_call_actor directly

Name Type Required Description

actor string required Actor ID or full name in 'username/name' format (e.g. 'apify/rag-web-browser')

output object optional JSON object with boolean flags to control which fields are returned. Always specify this to avoid a large token-heavy response. Set only the fields you need to true. Available fields: description, inputSchema, mcpTools, metadata, outputSchema, pricing, rating, readme, stats. All default to true if omitted (very large response) except mcpTools. Example: {"inputSchema": true}

apifymcp_fetch_apify_docs # Fetch the full content of an Apify or Crawlee documentation page by its URL. Use this after finding a relevant page with apifymcp_search_apify_docs. When to use: - You have a documentation URL and need the complete page content - User asks for detailed documentation on a specific Apify or Crawlee page When NOT to use: - You don't have a URL yet — use apifymcp_search_apify_docs first 1 param ▾

Fetch the full content of an Apify or Crawlee documentation page by its URL. Use this after finding a relevant page with apifymcp_search_apify_docs. When to use: - You have a documentation URL and need the complete page content - User asks for detailed documentation on a specific Apify or Crawlee page When NOT to use: - You don't have a URL yet — use apifymcp_search_apify_docs first

Name Type Required Description

url string required Full URL of the Apify or Crawlee documentation page (e.g. 'https://docs.apify.com/platform/actors')

apifymcp_get_actor_run # Get detailed information about a specific Actor run by runId. Returns run metadata (status, timestamps), performance stats, and resource IDs (datasetId, keyValueStoreId, requestQueueId). When to use: - You have a runId from apifymcp_call_actor (async mode) and want to check its status - User asks about details of a specific run started outside the current conversation When NOT to use: - The run was just started via apifymcp_call_actor in sync mode — results are already in the response - You want the output data — use apifymcp_get_actor_output with the datasetId 2 params ▾

Get detailed information about a specific Actor run by runId. Returns run metadata (status, timestamps), performance stats, and resource IDs (datasetId, keyValueStoreId, requestQueueId). When to use: - You have a runId from apifymcp_call_actor (async mode) and want to check its status - User asks about details of a specific run started outside the current conversation When NOT to use: - The run was just started via apifymcp_call_actor in sync mode — results are already in the response - You want the output data — use apifymcp_get_actor_output with the datasetId

Name Type Required Description

runId string required The ID of the Actor run

waitSecs integer optional Maximum seconds to wait for the run to reach a terminal state (SUCCEEDED, FAILED, ABORTED, TIMED-OUT). 0 returns immediately with the current status. Cap: 45. Default: 30.

apifymcp_get_dataset_items # Retrieve items from a dataset with pagination, field selection, and sorting. Use clean=true to skip empty items and hidden fields. Supports dot notation for nested field selection. 8 params ▾

Retrieve items from a dataset with pagination, field selection, and sorting. Use clean=true to skip empty items and hidden fields. Supports dot notation for nested field selection.

Name Type Required Description

datasetId string required Dataset ID or username~dataset-name.

clean boolean optional If true, returns only non-empty items and skips hidden fields (those starting with #).

desc boolean optional If true, returns results in reverse order (newest to oldest).

fields string optional Comma-separated list of fields to include. Supports dot notation for nested fields, e.g. metadata.url.

flatten string optional Comma-separated fields to flatten into dot-notation keys. Usually inferred automatically from dot notation in fields.

limit integer optional Maximum number of items to return. Defaults to 20.

offset number optional Number of items to skip for pagination. Default is 0.

omit string optional Comma-separated list of fields to exclude from results.

apifymcp_get_key_value_store_record # Retrieve a record (JSON, text, or binary) from a key-value store by its key. 2 params ▾

Retrieve a record (JSON, text, or binary) from a key-value store by its key.

Name Type Required Description

keyValueStoreId string required Key-value store ID or username~store-name.

recordKey string required Key of the record to retrieve.

apifymcp_rag_web_browser # Web browser for AI agents and RAG pipelines. Queries Google Search, scrapes the top N pages, and returns content as Markdown. Can also scrape a specific URL directly. When to use: - User wants current/immediate data (e.g. 'Get flight prices for tomorrow', 'What's the weather today?') - User needs to fetch specific content now (e.g. 'Fetch news from CNN', 'Get product info from Amazon') - User has time indicators like 'today', 'current', 'latest', 'recent', 'now' When NOT to use: - User needs repeated/scheduled scraping of a specific platform — search for a dedicated Actor using apifymcp_search_actors instead 4 params ▾

Web browser for AI agents and RAG pipelines. Queries Google Search, scrapes the top N pages, and returns content as Markdown. Can also scrape a specific URL directly. When to use: - User wants current/immediate data (e.g. 'Get flight prices for tomorrow', 'What's the weather today?') - User needs to fetch specific content now (e.g. 'Fetch news from CNN', 'Get product info from Amazon') - User has time indicators like 'today', 'current', 'latest', 'recent', 'now' When NOT to use: - User needs repeated/scheduled scraping of a specific platform — search for a dedicated Actor using apifymcp_search_actors instead

Name Type Required Description

query string required Google Search keywords or a specific URL to scrape. Supports advanced search operators.

maxResults integer optional Maximum number of top Google Search results to scrape and return. Ignored when query is a direct URL. Higher values increase response time and compute cost significantly — keep low (1-3) for latency-sensitive use cases. Default: 3.

outputFormats array optional Output formats for the scraped page content. Options: 'markdown', 'text', 'html' (default: ['markdown'])

waitSecs integer optional Max seconds (0–45, default 30) to cap the wait for the Actor run to reach terminal state. For long-running Actors the response returns at the cap with the current run status; follow `nextStep` to poll via get-actor-run. Set to 0 to fire-and-forget.

apifymcp_search_actors # 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. When to use: - Find what scraping tools exist for a platform (e.g. 'What tools can scrape Instagram?') - Discover available Actors for a use case (e.g. 'Find an Actor for Amazon products') - Browse existing solutions before calling an Actor When NOT to use: - User wants immediate data retrieval — use apifymcp_rag_web_browser instead - You already know the Actor ID — use apifymcp_fetch_actor_details or apifymcp_call_actor directly Always do at least two searches: first with broad keywords, then with more specific terms if needed. 3 params ▾

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. When to use: - Find what scraping tools exist for a platform (e.g. 'What tools can scrape Instagram?') - Discover available Actors for a use case (e.g. 'Find an Actor for Amazon products') - Browse existing solutions before calling an Actor When NOT to use: - User wants immediate data retrieval — use apifymcp_rag_web_browser instead - You already know the Actor ID — use apifymcp_fetch_actor_details or apifymcp_call_actor directly Always do at least two searches: first with broad keywords, then with more specific terms if needed.

Name Type Required Description

keywords string optional Space-separated keywords to search Actors in the Apify Store. Use 1-3 simple terms (e.g. 'Instagram posts', 'Amazon products'). Avoid generic terms like 'scraper' or 'crawler'. Omitting keywords or passing an empty string returns popular/general Actors — always provide keywords for relevant results.

limit integer optional Maximum number of Actors to return (1-100, default: 5)

offset integer optional Number of results to skip for pagination (default: 0)

apifymcp_search_apify_docs # Search Apify and Crawlee documentation using full-text search. Use keywords only, not full sentences. Select the documentation source explicitly via docSource. Sources: - 'apify': Platform docs, SDKs (JS, Python), CLI, REST API, Academy, Actor development - 'crawlee-js': Crawlee JavaScript web scraping library - 'crawlee-py': Crawlee Python web scraping library When to use: - User asks how to use Apify APIs, SDK, or platform features - You need to look up Apify or Crawlee documentation When NOT to use: - You already have a documentation URL — use apifymcp_fetch_apify_docs directly 4 params ▾

Search Apify and Crawlee documentation using full-text search. Use keywords only, not full sentences. Select the documentation source explicitly via docSource. Sources: - 'apify': Platform docs, SDKs (JS, Python), CLI, REST API, Academy, Actor development - 'crawlee-js': Crawlee JavaScript web scraping library - 'crawlee-py': Crawlee Python web scraping library When to use: - User asks how to use Apify APIs, SDK, or platform features - You need to look up Apify or Crawlee documentation When NOT to use: - You already have a documentation URL — use apifymcp_fetch_apify_docs directly

Name Type Required Description

query string required Algolia full-text search query using keywords only (e.g. 'standby actor', 'proxy configuration'). Do not use full sentences.

docSource string optional Documentation source to search. Options: 'apify' (default), 'crawlee-js', 'crawlee-py'

limit number optional Maximum number of results to return (1-20, default: 5)

offset number optional Offset for pagination (default: 0)