A scraping API your agent can call, and pay for, per result
Last updated
Datapika is a pay-per-result scraping API for AI agents: 10 actors on the Apify platform, each callable as an MCP tool or a REST endpoint, billed per delivered row with no subscription. As of August 2026 prices start at $0.0005 per record on the hiring signals scanner and reach $0.005 per job on the flagship job board actor. One MCP URL preloads every tool into Claude Code, Cursor, VS Code or Codex CLI, and a maxTotalChargeUsd cap fixes a hard budget before the call. Plain-text llms.txt, AGENTS.md and per-actor OpenAPI specs let the agent read inputs and pricing itself.
What does a pay-per-result scraping API cost an AI agent?
Every Datapika run bills per delivered result and nothing else. There is no monthly plan, no seat and no minimum: a free Apify account is enough to start, and that account is charged for the rows an actor returns. The rate is set per actor. As of August 2026 the Apify Store lists the hiring signals scanner at $0.0005 per record, the Google Flights actor at $0.0015 per itinerary, the Reddit actor at $0.002 per post, the Google Maps actor at $0.003 per place and the multi-board job actor at $0.005 per job. Trend reports are priced per report instead, at $0.35 for the standard tier. Because the unit is a row, an agent can compute the cost of a call before making it and skip calls that exceed its allowance.
- A 100-job sweep on the job board actor costs $0.50; 1,000 hiring-signal company checks also cost $0.50
- 1,000 Google Flights itineraries cost $1.50; a 1,000-place Google Maps run is $3.00 at a flat $0.003 per place
- maxTotalChargeUsd on any REST run stops the platform at that ceiling instead of overspending
- The TikTok actor returns an unbilled error row for a failed URL, and the Airbnb actor charges nothing for empty or failed runs, so retries do not compound cost
How does an AI agent connect to Datapika over MCP?
The actors are exposed through the Apify MCP server over streamable HTTP with OAuth. One URL preloads every Datapika tool by listing each slug after fetch-actor-details, for example https://mcp.apify.com/?tools=fetch-actor-details,openclawai/job-board-scraper,openclawai/reddit-scraper and so on through the catalog. Each actor also has a minimal single-tool URL of the form https://mcp.apify.com/?tools=fetch-actor-details,openclawai/<slug>, which is the right choice when an agent needs only one source. The paired fetch-actor-details tool is what makes the setup agent-safe. Before running anything, the model can read the actor's input schema and current price and decide whether the call fits the budget it was given. On first use the client opens Apify OAuth in the browser; a free account completes it, and every run after that bills per result to the same account.
- Claude Code: claude mcp add --transport http datapika "<mcp url>"
- Cursor: the Add to Cursor button on datapika.com/mcp, or the URL in .cursor/mcp.json
- VS Code: .vscode/mcp.json with type http; Codex CLI: codex mcp add datapika --url "<mcp url>"
- Example prompt: find remote senior data engineer roles posted in the last 24 hours, dedupe across boards, return salary ranges as a table
When should an agent use the REST API instead of MCP?
Use REST when the agent runs unattended, on a schedule, or inside a pipeline that has no MCP client. A single POST to https://api.apify.com/v2/acts/openclawai~<slug>/run-sync-get-dataset-items?format=json with a Bearer token returns dataset rows directly as JSON. The synchronous endpoint returns 408 after 300 seconds, so large sweeps should start a run, poll its status, then read the dataset when it finishes. Official Node and Python clients wrap both patterns, and the Apify CLI covers shell scripts. Each actor publishes an OpenAPI spec for its default build at https://apify.com/openclawai/<slug>/api/openapi with no auth required, so codegen or a tool-calling framework can build a typed client from it. Schedules and webhooks are platform features: run any actor every morning and push new rows to your stack.
- Sync: run-sync-get-dataset-items returns rows in one response for runs that finish inside 300 seconds
- Async: actor.call() then dataset.listItems() in the Node or Python client, required past the 300-second limit
- Budget: append maxTotalChargeUsd=<usd> to the run URL to cap spend per call
- Auth: an Apify API token in an Authorization: Bearer header, issued from a free account
How does an agent discover Datapika's tools without a human?
Three plain-text surfaces describe the catalog in a form a model can read directly. datapika.com/llms.txt follows the llms.txt convention: a one-paragraph description of the studio, every actor with its price and run URL, the MCP config URL, the guides, and a facts block. datapika.com/llms-full.txt carries every guide and actor description in one file for retrieval. datapika.com/AGENTS.md uses the installation, configuration and usage layout that coding agents already expect from repository AGENTS.md files: the MCP add command, the Bearer auth rule, the budget parameter, the 300-second timeout, and one line per actor with slug, price, docs link, input schema link and OpenAPI link. All three render from the same catalog data as the pages, so a price never drifts between what a human reads and what an agent reads.
- llms.txt: catalog map with per-actor price and run URL, plus the one-line MCP install
- AGENTS.md: installation, configuration and usage sections, including timeouts and budget caps
- Input schema at https://apify.com/openclawai/<slug>/input-schema; OpenAPI at https://apify.com/openclawai/<slug>/api/openapi
- Pages, sitemap, llms.txt and AGENTS.md share one data source, so a price change updates everywhere at once
| Surface | What the agent gets | URL pattern | Auth |
|---|---|---|---|
| MCP, whole catalog | Every actor as a tool, plus fetch-actor-details for schema and price on demand | https://mcp.apify.com/?tools=fetch-actor-details,openclawai/job-board-scraper,openclawai/reddit-scraper,... (one slug per actor) | Apify OAuth, free account |
| MCP, single actor | One tool plus fetch-actor-details | https://mcp.apify.com/?tools=fetch-actor-details,openclawai/<slug> | Apify OAuth, free account |
| Cursor one-click install | A preconfigured datapika MCP server entry in Cursor | https://cursor.com/en/install-mcp?name=datapika&config=<base64 JSON containing the MCP url> | Apify OAuth on first use |
| REST, synchronous | Dataset rows as JSON in one response, for runs under 300 seconds | POST https://api.apify.com/v2/acts/openclawai~<slug>/run-sync-get-dataset-items?format=json&maxTotalChargeUsd=<usd> | Bearer API token |
| REST, asynchronous | A run to poll, then the dataset read; use past the 300-second limit | client.actor("openclawai/<slug>").call(input), then client.dataset(run.defaultDatasetId).listItems() | Bearer API token |
| OpenAPI spec | Typed request and response schema for the actor's default build | https://apify.com/openclawai/<slug>/api/openapi | None |
| Input schema | Field names, types and defaults for the actor input | https://apify.com/openclawai/<slug>/input-schema | None |
| llms.txt | Catalog map: actors, prices, run URLs, MCP config, guides and facts | https://datapika.com/llms.txt (full text at https://datapika.com/llms-full.txt) | None |
| AGENTS.md | Installation, configuration and usage instructions with one line per actor | https://datapika.com/AGENTS.md | None |
How to do it
- 1.For an interactive agent, add the MCP server: claude mcp add --transport http datapika "https://mcp.apify.com/?tools=fetch-actor-details,openclawai/job-board-scraper" (or the full catalog URL from datapika.com/mcp for all 10 tools), then complete Apify OAuth once with a free account.
- 2.For unattended pipelines, POST the actor input to https://api.apify.com/v2/acts/openclawai~job-board-scraper/run-sync-get-dataset-items?format=json&maxTotalChargeUsd=1 with an Authorization: Bearer token; the response body is the dataset as JSON.
- 3.Let the agent read datapika.com/AGENTS.md or call fetch-actor-details to learn each actor's input fields and per-row price, and set maxResults to the rows it actually needs.
- 4.Read the rows back as JSON. If a sweep may pass 300 seconds, start it asynchronously and poll, then fetch the dataset; add a schedule and webhook for recurring pulls.
Questions, answered
Does Datapika require a subscription or a minimum spend?
No. Every actor bills per delivered result to an Apify account, which is free to create and needs no card to start. You pay the per-row price of each actor you call, from $0.0005 per record on the hiring signals scanner to $0.005 per job on the multi-board job actor, as of August 2026. Trend reports are priced per report instead, at $0.35 for the standard tier.
Can an AI agent pay for a scraping call without a human-created account?
Not reliably yet. Runs bill against an Apify account today, so a person creates the account and token once and the agent uses them. The platform is rolling out agentic payment protocols, x402 and MPP prepaid tokens, that would let an agent buy usage directly; support varies by actor and account status, so check the platform docs before relying on it. Until then, an agent-held token plus maxTotalChargeUsd is the working pattern.
What happens when a scraping run exceeds the 300-second synchronous limit?
The run-sync-get-dataset-items endpoint returns HTTP 408 after 300 seconds. The run is not the problem, the open connection is: switch to the asynchronous pattern, start the run, poll its status, then read the dataset items once it finishes. The official Node and Python clients do this with actor.call() followed by a dataset listItems() read. Large multi-board job sweeps and full comment-tree Reddit pulls are the usual cases.
How does an agent stop a scraping run from overspending?
Two controls. maxTotalChargeUsd is a query parameter on any REST run, and the platform stops the run when charges reach that ceiling. maxResults, the per-actor input, limits how many rows the actor tries to return in the first place. Because the MCP setup pairs every tool with fetch-actor-details, an agent can also read the price per row before it runs and multiply: a 100-job sweep at $0.005 per job is $0.50.
Why not call the official APIs of these sites from an agent instead?
Most of the sources Datapika covers offer no public API for this data to independent developers, and where an official API does exist it needs its own key, quota and billing arrangement. Datapika reads public pages and returns normalized JSON, so the agent uses one auth and one price model across every source: one Apify token, per-row pricing, and the same sync or async run pattern whether the target is a job board, Reddit, Google Maps or Google Flights.
Keep reading
Use cases
Hiring signals API: who is hiring, at $0.0005 per company
Use cases
Cross-platform trend analysis: 13+ platforms, one report
Scrape guides
How to scrape Reddit without the API (2026 guide)
Scrape guides
Google Maps scraper API: 1,000 places for $3.00
Scrape guides
Scrape LinkedIn Jobs Without Login, Cookies, or an API