AI agents need web data, structured leads, and site content that APIs do not always hand over. Apify packages that work as Actors: serverless cloud jobs that take JSON input, run in the cloud, and return datasets you can export.
The hard part is not "should we scrape." It is which path to take:
1. Run a ready made Actor from Apify Store. 2. Build a custom Actor (or scraper) on the Apify platform with the SDK. 3. Let an AI agent discover and run tools through the Apify MCP server.
This page compares those options from official Apify documentation and pricing pages, checked between November 5 and November 13, 2026. It is a product and workflow guide from public docs, not a hands-on lab report. Nero Labs / Nero Engine already uses Apify Actors in production workflows, which is why this comparison exists, but every claim below is tied to public sources.
Try Apify (Paid Link)
The quick answer
- Pick a Store Actor when the job is a common scrape or automation (maps, social, ecommerce, SERP, site crawl) and a published Actor already returns the fields you need. Time to first rows is minutes, not days.
- Build a custom scraper / Actor when you need fields, crawl logic, auth, or anti bot handling that no Store Actor exposes, or when you want full ownership of the code path.
- Use Apify MCP when an AI agent or coding assistant should search the Store, read Actor schemas and pricing, start runs, and pull dataset items without a separate integration for every Actor.
- Budget (US, before tax, November 13, 2026): Free plan at $0 with $5 included usage per month. Self serve paid plans start at Starter $19/month ($17/month billed yearly), Scale $199/month ($179/month yearly), Business $999/month ($899/month yearly). Store Actors usually bill pay per event, pay per usage, or both, on top of that plan usage.
- MCP caveats: running Actors and reading storage needs auth (OAuth or API token). Discovery and docs tools can work without an account. Full permission Actors are excluded from MCP search and execution for security. Rental Actors are also excluded because subscription billing does not fit on demand runs.
Side by side
| Store Actor | Custom scraper / Actor | Apify MCP layer | |
|---|---|---|---|
| Main job | Run a published marketplace tool | Own the scrape or automation code | Let an agent find, inspect, run, and read Actors |
| Time to first data | Minutes if a good Actor exists | Hours to days of build and test | Minutes after the MCP client is connected |
| Who maintains site changes | Actor author (usually) | Your team | Still the Actor author or your custom code |
| Field control | Whatever the Actor outputs | Full control | Same as the Actor you call |
| How you pay | Plan usage + Actor pricing | Plan usage for your own Actor | Same underlying Actor / plan billing when runs execute |
| Best for agents | Known Actor name or pinned tools | Agent or human runs your Actor by name | Agent searches Store and docs on demand |
| Main risk | Price changes, quality drift, Actor leaving Store | You own bugs and anti bot work | Wait limits, tool selection, excluded Actor types |
Plan prices are from apify.com/pricing on November 13, 2026. Exact Actor costs live on each Actor page and change, so treat Marketplace prices as live data.
What an Actor actually is
Per Apify's Actor docs, an Actor is a serverless cloud program: structured JSON in, work in the cloud (scraping, browser automation, processing), structured results out. You can run Actors from Console, API, CLI, schedules, or from other Actors.
A proper Actor ships with a Dockerfile, README, input and output schemas, access to Apify storage (datasets, key value stores, and related run artifacts), and metadata such as name, author, and version. That packaging is why Store Actors feel like products and homemade scripts feel like chores. The platform gives every Actor an API surface, a form UI, storage, and scheduling whether you bought a Store tool or wrote your own.
Path 1: Apify Store Actors
Apify Store markets itself as a marketplace of ready to run tools for AI, with 118,000+ Actors listed on the Store page as of the November 13, 2026 check. Treat that as Apify's public marketing count. The searchable catalog moves over time; always search for the site or data source you need rather than trusting a single headline number.
Store Actors fit when the site or data type is common, the README and output schema already match your fields, paying per event beats babysitting selectors, or an agent should try an existing tool before anyone opens an editor.
Store pricing models from Apify pricing docs:
- Pay per event: fixed prices for developer-defined events (start, result row, and similar). Many include platform usage; some charge usage separately. Check the Actor page.
- Pay per usage: no developer surcharge; you pay compute units, transfer, storage, and proxies.
- Both: event fees plus usage.
Compute uses compute units (CUs). Apify defines 1 CU = 1 GB of RAM for 1 hour. CU price is listed at $0.2 on Free/Starter, $0.16 on Scale, and $0.13 on Business (November 13, 2026 pricing page).
Tradeoffs: you move fast, but you inherit the author's fields and quality bar. Authors can change pricing. Popular Actors usually have better docs; long-tail ones can be quieter. For agents, schema clarity and quality ranking matter as much as raw capability.
Path 2: custom scrapers and custom Actors
Building your own Actor is the right move when Store options stop at "almost."
Apify's build docs describe an Actor as ordinary code (JavaScript/TypeScript, Python, or any Dockerized runtime) plus a definition: actor.json, Dockerfile, and schemas. The Apify SDK covers platform lifecycle, input, storage, proxy helpers, and related Actor concerns. Crawling libraries such as Crawlee are commonly paired with the SDK for crawl logic (check current SDK docs when you start a project).
Custom work fits when you need fields no Store Actor returns, when login or anti-bot paths need your own session strategy, when compliance demands auditable code, or when the scrape is a durable product asset.
You still get Apify datasets, schedules, and APIs. You mainly trade speed for control, and you own the 2 a.m. site redesign.
Middle ground: start with a Store Actor for discovery, then rewrite only what fails your field or reliability bar.
Path 3: where Apify MCP fits
Model Context Protocol (MCP) is an open way for AI clients to call tools. Apify's hosted MCP server at https://mcp.apify.com turns Store discovery, Actor runs, storage reads, and docs search into tools an agent can call.
From Apify's MCP docs (November 5, 2026):
- Agents can search Actors, fetch Actor details (input/output schema, README, pricing), call Actors, then read dataset items (and related run/storage tools).
call-actorwaits up towaitSecs(0 to 45, default 30) and returns run status and storage IDs, not the scraped rows. Results come fromget-dataset-itemsusing those IDs.- Default tool load includes the
actorsanddocscategories, plus Actors such asapify/rag-web-browserandapify/web-fetch, andreport-problem. - You can narrow tools with URL parameters, or pin specific Actors.
- Without an account, only discovery/docs tools work:
search-actors,fetch-actor-details,search-apify-docs,fetch-apify-docs. - With OAuth or an API token, agents can run Actors and read storage. Local stdio via
@apify/actors-mcp-serveris available when a client cannot use the hosted HTTP server. - Docs list a rate limit of up to 30 requests per second per user.
- Full permission Actors are excluded from MCP search/execution. Rental Actors are also excluded from that path.
MCP is not a third pricing product. It is a control plane. The agent still pays for Actor runs and platform usage. The value is dropping glue code so an agent can pick tools the way a human browses Store.
For agent products, that is the atajo (shortcut): one MCP connection instead of one integration per scrape target.
Decision guide
Start with Store + MCP discovery when the task is a well known public data shape, you can accept the Actor schema with light post processing, you want an agent to try two or three Actors and keep the winner, or speed matters more than owning every line.
Write a custom Actor when schema gaps block the product, failure cost is high and you need tests plus code review on the scraper, or you plan to publish or monetize the Actor later.
Prefer MCP orchestration when humans should not babysit Console for every exploratory run, coding agents need docs and Store search in the same loop, or tool selection should stay dynamic.
Stay careful when jobs regularly need more than the MCP call-actor wait window (plan async polling with run tools), the best Actor is rental or full permission (use Console/API with a human approval step), or you are relying on agentic payment flows (read Apify's current agent payment docs first).
Pricing snapshot (platform, not every Actor)
Checked on apify.com/pricing, November 13, 2026. Annual billing is listed as about 10% off paid plans.
| Plan | Monthly | Annual (per month) | Included usage / month | Max concurrent runs |
|---|---|---|---|---|
| Free | $0 | $0 | $5 | 5 |
| Starter | $19 | $17 | $19 | 32 |
| Scale | $199 | $179 | $199 | 128 |
| Business | $999 | $899 | $999 | 256 |
Apify also lists a Creator plan aimed at people building and publishing Actors, with Store limits described on the Creator plan page. Recheck that page if Creator is your path.
Proxy and add on prices vary by plan and matter a lot for custom crawls. Unused prepaid usage does not roll over, per Apify's pricing FAQ. Paying plans can continue into overage up to a configured usage limit; Free blocks when included usage is gone until the next cycle.
A practical workflow
1. Describe the dataset, not the vibe. "Company name, website, city, employee band from this directory" beats "get me leads." 2. Search Store (human or search-actors over MCP) for the site or data type. 3. Read Actor details: input schema, pricing model, README warnings. 4. Run a small sample with tight item or spend caps. Confirm fields and cost per row. 5. Automate with schedules, API, or MCP only after the sample looks sane. 6. Escalate to custom only when Store Actors fail the field, auth, or reliability bar twice, not once.
Who should pick what
- Solo builders: Store Actors + hosted MCP first.
- Content and SEO teams: Store first; custom only for stubborn sites.
- Agent product teams: MCP for discovery, pinned Actors for production.
- Strict SLA data teams: custom or wrapped Store Actors, plus budgets and human review on high-risk targets.
- Nero Engine style shops: Store for commodity extraction, custom Actors for stable product contracts, MCP so coding agents can explore without fifteen browser tabs.
Limits and honesty checks
- Store counts, Actor prices, and plan details change. Recheck before publishing quoted budgets.
- The 118,000+ Store figure is from Apify's Store marketing page on the check date, not a live API recount in this draft.
- MCP tool defaults can evolve; use docs.apify.com/integrations/mcp as the live reference.
Bottom line
Store Actors win on speed. Custom scrapers win on control. Apify MCP wins when an AI agent should navigate that marketplace and platform without a hand written integration for every target.
If an Actor already returns the rows you need, run it. If it almost does, measure the gap before you rewrite the internet. If your agent needs to choose tools in real time, connect MCP, keep spend caps tight, and graduate the winners into pinned production tools.
Sources
Docs checked on November 5, 2026; Store and pricing rechecked on November 13, 2026:
- Apify MCP server docs: https://docs.apify.com/integrations/mcp
- Apify MCP landing: https://mcp.apify.com/
- Agent onboarding: https://docs.apify.com/get-started/agent-onboarding
- Actors overview: https://docs.apify.com/platform/actors
- Build Actors: https://docs.apify.com/get-started/build-actors
- Apify SDK: https://docs.apify.com/sdk
- Apify Store: https://apify.com/store
- Apify pricing: https://apify.com/pricing