Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
UI_MODENoSet to true to enable MCP Apps widget rendering in tool responses. Disabled by default.false
APIFY_TOKENYesYour Apify API token.
TELEMETRY_ENABLEDNoSet 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 to resources/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 datasetId becomes https://api.apify.com/v2/datasets/{datasetId}/items) and read it via resources/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 limit and offset to 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/list enumerates the common shapes with their paging parameters.

Tool dependencies and disambiguation

Tool dependencies

  • call-actor:

    • Use fetch-actor-details first 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 waitSecs parameter (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 with get-dataset-items).

Tool disambiguation

  • search-actors vs fetch-actor-details: search-actors finds Actors; fetch-actor-details retrieves detailed info, README, and schema for a specific Actor.

  • search-actors vs apify/rag-web-browser: search-actors finds 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; use call-actor only 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

CapabilityDetails
tasks
{
  "list": {},
  "cancel": {},
  "requests": {
    "tools": {
      "call": {}
    }
  }
}
tools
{}
logging
{}
prompts
{}
resources
{}

Tools

Functions exposed to the LLM to take actions

NameDescription
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:

  • 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 (e.g., "Show me scrapers for news sites")

  • Learn about MCP servers or AI agents available in the Store

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:

  • Prefer broad, generic keywords - use just the platform name (e.g. "Instagram" instead of "Instagram scraper").

  • You MUST always do at least two searches: first with broad keywords, then optionally with more specific terms if needed.

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. url: string, maxResults?: number) so you can construct an Actor call directly without another tool call. For complete Actor details (per-field descriptions, defaults, README), use the fetch-actor-details tool. The search is limited to publicly available Actors and excludes rental and restricted Actors.

Returns list of Actor cards with the following info:

  • Title: Markdown header linked to the Store page, followed by the full Actor name in code format

  • URL: Direct Store link

  • Description: Actor description or fallback

  • Pricing: Details with pricing link

  • Stats: Total and monthly users, bookmarks

  • Rating: Out of 5 (if available)

  • Developed by: Username linked to profile, marked (Apify) or (community)

  • Categories: Formatted or "Uncategorized"

  • Last modified: Date (if available)

  • Input fields: Inline list of input field names and types (e.g. url: string, maxResults?: number); ? marks optional fields, ... (+N more) marks a truncated list

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:

  • Default: All fields true except mcpTools

  • Selective: Set desired fields to true (e.g., output: { inputSchema: true })

  • Common patterns: inputSchema only, description + readme, mcpTools for MCP Actors

The 'readme' field returns the summary when available, full README otherwise. Use when querying Actor details, documentation, input requirements, or MCP tools.

EXAMPLES:

  • What does apify/rag-web-browser do?

  • What is the input schema for apify/web-scraper?

  • What tools does apify/actors-mcp-server provide?

call-actorA

Call any Actor from the Apify Store.

WORKFLOW:

  1. Use fetch-actor-details to get the Actor's input schema

  2. Call this tool with the actor name and proper input based on the schema

If the actor name is not in "username/name" format, use search-actors to resolve the correct Actor first.

For MCP server Actors:

  • Use fetch-actor-details with output={ mcpTools: true } to list available tools

  • Call using format: "actorName:toolName" (e.g., "apify/actors-mcp-server:fetch-apify-docs")

IMPORTANT:

  • Waits up to waitSecs (default 30s) for completion; returns run status and storage IDs, and with waitSecs > 0 also reports dataset field metadata

  • Use get-dataset-items with the datasetId to fetch results; non-terminal runs include a nextStep with polling instructions

  • Use dedicated Actor tools when available for better experience

There are two ways to run Actors:

  1. Dedicated Actor tools: These are pre-configured tools, offering a simpler and more direct experience.

  2. Generic call-actor tool (call-actor): Use this when a dedicated tool is not available or when you want to run any Actor dynamically. This tool is especially useful if you do not want to add specific tools or your client does not support dynamic tool registration.

USAGE:

  • Always use dedicated tools when available

  • Use the generic call-actor tool only if a dedicated tool does not exist for your Actor.

  • Use waitSecs (0–45) to control how long to wait. Default 30s returns results for fast actors. Use waitSecs: 0 to start and return immediately for long-running actors.

EXAMPLES:

  • user_input: Get instagram posts using apify/instagram-scraper

get-actor-runA

Get detailed information about a specific Actor run.

Returns run result: status, storages (datasets/keyValueStores alias map), stats, summary, nextStep.

  • summary describes the past (e.g. "SUCCEEDED in 22s. 47 items; 3 fields available.").

  • nextStep prescribes one primary follow-up action with identifiers interpolated (e.g. "Use get-dataset-items with datasetId=...").

  • waitSecs (0–45, default 30) waits up to that many seconds for terminal status before returning.

USAGE:

  • Use to check the status of a run started by any Actor-running tool.

  • Pass waitSecs > 0 to block until terminal (or until the cap elapses).

USAGE EXAMPLES:

  • user_input: Show details of run y2h7sK3Wc

  • user_input: Wait for run y2h7sK3Wc to finish

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:

  • Use when you need to read data from a dataset (all items or only selected fields).

USAGE EXAMPLES:

  • user_input: Retrieve results from dataset abc123

  • user_input: Get only metadata.url and title from dataset username~my-dataset

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:

  • Use when you need to retrieve a specific record (JSON, text, or binary) from a store.

USAGE EXAMPLES:

  • user_input: Get record INPUT from store abc123

  • user_input: Get record data.json from store username~my-store

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:

  • Use when you need to stop a run that is taking too long or misconfigured.

USAGE EXAMPLES:

  • user_input: Abort run y2h7sK3Wc

  • user_input: Gracefully abort run y2h7sK3Wc

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 (docs.apify.com/platform) and Academy content (docs.apify.com/academy) on the same topic, prefer the 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:

  • Use when you need the complete content of a specific docs page for detailed answers.

USAGE EXAMPLES:

report-problemA

Report a problem with Apify's MCP tools or Actors to the Apify team.

Call it when:

  • A tool or Actor is missing, errors, times out, or returns a confusing, wrong, or empty result.

  • You cannot complete the user's request with the available tools.

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

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A4.4/5.0

Scored across 10 tools

Disambiguation5/5

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.

Naming Consistency5/5

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.

Tool Count5/5

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.

Completeness4/5

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.

Maintenance

ActivityStale
ResponsivenessNo recent community issues