Scrape a Cloudflare-protected site for $0.40 per 1,000 pages: the session rung
30 Oct 2026 · 7 min read
Web scraping API and website crawler for AI and data teams
Crawl any website, get clean Markdown or structured JSON, and know exactly what changed since the last run. MeshArc delivers the results straight to your database, warehouse or vector store — and you only pay for the pages it actually read.
Reach every page. Remember every site. One API call crawls a site; one more keeps it watched. A refused page, a 404 and a page that did not change all cost nothing.
no card · Python and Node SDKs · MCP server for Claude and Cursor · blocked pages and 404s are free
every number on this page came off a real run, recorded in the repo
Most teams glue together a scraper, a change monitor and an ETL job, then spend their weeks keeping all three alive. This is the three of them as one thing.
A ladder from a plain fetch to a real Chrome to a residential address to a paid answer. A refused page climbs one rung, never two; a refusal costs nothing; and the site remembers where it landed, so the platform learns a site once and every workspace benefits.
Every run is compared with the last, page by page and field by field. Consent banners, rotating widgets and volatile blocks are suppressed, so “Accept all cookies” never reads as fourteen modified pages. A page the site declined this time is withheld, never “removed”.
Rows push themselves after each run to object stores, warehouses, databases, vector stores and streams — filtered, mapped and dropped on the way out, upserted by URL and content hash. Vector stores chunk and embed on your key.
Search Google and get the pages, not just the links. Hand a question to an AI agent that reads the web for you and shows the pages behind its answer — for one question, or every row of a spreadsheet. Then put it on a schedule and hear only when the answer changes.
You never choose the mode — the ladder starts cheap and climbs one rung per refusal, never two. A page that needs more than your tier allows is not charged and is marked TIER_LIMIT: “this page costs more than you allow”, with the rung that would have read it. maxCredits caps any single page.
Added, removed, modified, same, withheld, unverified, skipped — per page, per run. A page the site declined this time is withheld, never “removed”. Accept or ignore each change; mail a run’s record, or a digest on Monday morning in your own time zone.
Rail funding package — consultation decision
robots.txt, well-known paths, <link rel=sitemap> and feeds, then indexes walked two deep — gzip, text sitemaps, lastmod, Google News, hreflang, image and video sitemaps. Every file is fetched through the ladder, so a blocked sitemap is climbed, not skipped.
Push, not pull. Every connector is tested from the UI before it runs, gets its own sync history, and can be scoped to one project or the whole workspace. Vector stores chunk and embed on your embedding key.
This is a complete scraping API, not only a monitor. Point it at one URL or a whole site and choose what comes back — then narrow it until you are paying for nothing else.
Every asynchronous verb returns the same envelope — id, kind, status, progress, creditsUsed, data, next — with cursor pagination, Idempotency-Key, X-Request-Id and X-MeshArc-Credits on every response, and typed error codes. Keys carry scopes, a project allow-list, an expiry and their own rate limit.
curl -X POST https://api.mesharc.dev/v1/crawl \
-H "Authorization: Bearer $MESHARC_KEY" \
-H "Idempotency-Key: rail-funding-48" \
-d '{
"url": "https://www.gov.uk/news",
"mode": "sitemap_first",
"formats": ["markdown", "json"],
"fields": ["title", "published_at", "author"],
"tier": "browser"
}'
from mesharc import MeshArc
arc = MeshArc() # reads MESHARC_API_KEY
job = arc.crawl("https://www.gov.uk/news", useSitemap=True, wait=True)
for page in job.pages():
print(page["url"], page["verdict"], page["credits"])
# keep it, and it watches
project = job.keep(name="gov.uk news", schedule="daily")
for entry in arc.changes(project["id"])["change"]["feed"]:
print(entry["kind"], entry["url"])
A plain fetch is one credit, a real browser four, a residential address sixteen. Change detection, sitemaps, destinations, exports and webhooks are on every plan. Refused pages and 404s are free.
Each of these is a page of its own: the problem in that team's words, the configuration that answers it, and what comes back.
A web scraping API fetches web pages for you and returns their content in a clean, usable form, handling proxies, JavaScript rendering and anti-bot measures out of sight. This one adds two things most do not: it remembers every site, so it can say what changed since last time, and it delivers the results into your own data stores.
Most scraping APIs sell requests: you are billed for the attempt, whatever came back. This one sells results — a refused page, a 404 and a page that did not change are all zero — and the second crawl of a site costs less than the first, because the rung that worked is remembered.
No. Every page starts as a plain fetch and the ladder climbs one rung per refusal — a session, a real browser, a residential address, a solved widget, a rented unblocker. You set the ceiling per project and maxCredits per request; the response says which rung read each page and what it cost.
Nothing. A page the site refused, whatever the ladder spent finding out, and a 404 or 410 are on the ledger at zero. A page that needs more than your tier allows is not charged and comes back TIER_LIMIT with the rung that would have read it.
Cloudflare’s “Just a moment” page needs no solver — a real browser waits it out and earns the site’s session, so every page after it is read at 2 credits. Captcha widgets on forms (Turnstile, reCAPTCHA v2 and v3) are opt-in per project: a checkbox is clicked for free first and an answer is bought only when the pictures come. hCaptcha is detected and refused.
Into your own stores. After each run, rows push to S3, GCS, Azure Blob, BigQuery, Snowflake, Redshift, Databricks, ClickHouse, Postgres, MySQL, Mongo, Pinecone, Qdrant, Weaviate, pgvector, Kafka or a webhook — filtered, mapped and upserted by URL. Or pull CSV and JSONL exports. Model extraction and embeddings run on your own keys. Read about the eighteen destinations.
A cheapest-first ladder and success-only billing are not ours alone. What is: the session rung that reads a walled site at 2 credits after one render, a memory of every site shared across workspaces, and change detection, sitemaps and destinations sold as the product rather than bolted on. Prices are compared in dollars per thousand pages. Read about the comparison.
Yes. A search reads Google’s organic results — Bing’s when Google refuses — and can return each result’s page as Markdown in the same call. A results page every engine refused is free, and the same search within the hour costs nothing. Read about the web search API.
Ask it a question and it searches the web, reads the pages it needs and answers — in the format you ask for, with its values linked to the pages they were read on. It pays for the pages it reads, like any request, and the model’s tokens at the provider’s price plus 20%, never past the cap you set on the run. Read about the research agent.
Yes. Upload a CSV, write the question once with the columns in it, and every row is researched on its own, with a credit cap per row and the cost estimated before anything runs. The answers come back as new columns, linked to the pages they were read on. Read about data enrichment.
30 Oct 2026 · 7 min read
24 Oct 2026 · 8 min read
1,000 free credits, browser rendering included, no card. The playground answers in seconds.