Any page. Any data. Clean JSON.

Web scraping that returns what you actually want.

Dynamic - POST /v1/extract - 812ms - headless

REQUEST

curl -X POST https://api.scrapewithruno.com/v1/extract \
-H "X-API-Key: sk_live_Kx9mT3vQ2wRs" \
-d '{
"url": "https://imdb.com/name/nm0001570/",
"schema": [
{ "field": "name", "type": "string", "example": "John Doe" },
{ "field": "knownFor", "type": "array<string>", "example": ["Oppenheimer"] },
{ "field": "netWorth", "type": "float" }
]
}'

RESPONSE

{
"url": "https://imdb.com/name/nm0001570/",
"status": "success",
"render_mode": "headless",
"data": {
"name": "Rachel McAdams",
"knownFor": ["Mean Girls", "The Notebook", "Spotlight"],
"netWorth": 8000000.0
}
}


FEATURES

Scraping made easy.

Built for developers tired of babysitting broken scrapers and parsing raw HTML.

Typed JSON, Always

Strict coercion on every field: strings, integers, floats, booleans, dates, and arrays. Made to ensure no more ambiguous values slip through.

Plain JSON Schema

No CSS selectors, XPath, or complex DSLs. Simply define your field names, types, and examples to create a schema any developer can write in 30 seconds.

Static & Dynamic Keys

Bind a schema to a static key once in the dashboard. Requests require only a URL, with no schema attached. Or alternatively, attach a custom schema to every request using your dynamic API key, enabling higher flexibility.

Three Methods of Scraping

Scrape a single URL with /extract, fan-out to multiple URLs with /batch, or crawl recursively with /crawl using the same schema and a singular API key.

Semantic Extraction

Runo extracts by meaning, not DOM position. Site redesigns and HTML changes won't ever break your pipeline.

Explicit Nulls

Unresolvable fields return null. Runo never silently drops, never omitts and never foolheartedly guesses a wrong response. You always know exactly what was and was not found.

Field Hints

In the case of a very specific request, add a hint string to any field to have it injected directly into Runo's extraction instructions, ensuring you get exactly what you need.

Auto JS Rendering

Transparent fetch-first strategy. Auto-escalates to Playwright headless when JS detection or 403 triggers. "render_mode" in the response tells you exactly which path ran.

Bot Bypass

CAPTCHA solving and residential proxy access included with Pro & Scale plan. ~3-8% of requests trigger these layers. Amortized cost ~$0.00005-0.0001/req. Kill-switches prevent runaway spend.

HOW DOES COST COUNTING WORK?

Request Counting

/extract = 1 req. /batch = 1 req per URL. /crawl reserves max_pages upfront and refunds unused pages after completion.

Overage Policy

$0.002 per request beyond quota. Opt-in for Pro and Scale. Default is to reject requests at the limit.

HOW IT WORKS

01

Define your schema

List the fields you want. Name, type, example and add a hint if necessary.

02

Call the API

POST to /extract, /batch, or /crawl with your key and schema and Runo handles the rest.

03

Runo fetches and renders

Plain HTTP first. Auto-escalates to headless if JS-gating or empty response detected.

04

Get typed JSON back

Runo extracts and coerces every field. Clean validated JSON. Unresolvable fields return null.

VS. COMPETITORS

Why choose Runo?

With Runo, we attempted to find every API scraper pain-point and turn them around into an advantage. Here's how we compare to our competitors.

Competitors

Runo

Not scientifically proven. This is more of a guesstimate ;).

Other APIs Runo
Requests return raw HTML or Markdown, meaning you still have to parse it. Returns ready-to-use typed JSON. Zero post-processing needed on your end.
Schema requires CSS selectors, XPath, or proprietary DSL. Runo schemas are plain JSON: field name, type, and example.
Our competitors are brittle. Applications break when site HTML structure changes. Runo extracts by semantic meaning, not DOM position.
Silent failures occur relentlessly. Empty or wrong data returned with 200 OK. Unresolvable fields return null explicitly.
JS-heavy sites silently return empty content. Runo solves that through auto-escalation to headless rendering, transparent to you, the caller.
Crawling requires a separate product or extra setup. Runo is one API, three modes: /extract, /batch, /crawl.
Inconsistent returns per call. E.g. price comes back as a string, number, or null Runo has enforced type coercion: float, integer, string, boolean, date, array.

PRICING

Choose what works for you.

Our free tier is available to everyone with absolutely no charges. However, if the free tier doesn't fit your needs, you can choose to upgrade through one of our paid plans below.

Runo Free

$0

/month


  • 500 requests/month.
  • 1 request/min rate limit.
  • Enhanced bot detection + bypassing.
  • Overage opt-in.
Get Started for Free

Runo Starter

$17

/month


  • 15,000 requests/month.
  • 30 requests/min rate limit.
  • Enhanced bot detection + bypassing.
  • Overage opt-in.
Get Started

Runo Pro

$59

/month


  • 50,000 requests/month.
  • 120 requests/min rate limit.
  • Enhanced bot detection + bypassing.
  • Overage opt-in.
Get Started

Runo Scale

$449

/month


  • 500,000 requests/month.
  • 500 requests/min rate limit.
  • Enhanced bot detection + bypassing.
  • Overage opt-in.
Get Started

OVERAGE PRICING

Tier Deposit Total Requests Cost Per 1k/req
Pro
$5 3,300 $1.515
Pro
$500 440,000 $1.136
Scale
$5 4,500 $1.11
Scale
$500 525,000 $0.952

Cost per 1K/requests decreases linearly between $5 and $500.

AM

PR

LJ

RM

WW

KK

Loved by 1,305 users.

FAQs

If you can't find the answer to your question below, email us at hello@scrapewithruno.com

Yes. Model selection is automatic and included in the request cost.


For most Cloudflare protections, yes. Runo runs a multi-tier bypass process: TLS impersonation, hardened headless with full fingerprint spoofing, and session cookie persistence. It identifies Cloudflare, Datadome, PerimeterX, Akamai, and Incapsula on the first fetch and jumps straight to the appropriate countermeasure instead of wasting a failed attempt.

Sites using Cloudflare's interactive CAPTCHA challenges, or bot score thresholds that require a residential IP, are handled via CAPTCHA solving and T5 residential proxies. Both are included on Pro and Scale plans.


Runo is built for the open web: news, blogs, product pages, documentation, public social posts, forums. It doesn't reliably handle Amazon, Walmart, or major enterprise retail (which use full bot management suites); Tripadvisor, Yelp, and travel aggregators (IP-reputation walls); paywalled content like WSJ or Bloomberg (article bodies sit behind a login); or entertainment databases like IMDB (challenge shells on datacenter IPs). We document these limitations rather than paper over them.


Runo caps crawl jobs at 25% of your remaining monthly quota per job, so a single runaway crawl can't exhaust your account. Unused reserved pages are refunded immediately when the crawl finishes or is cancelled. If you need to go beyond the cap, pass "allow_large_crawl": true at your own discretion.


Yes. Every response includes an X-Job-ID header. Send DELETE /v1/jobs/{job_id} with the same API key to cancel. The job stops at the next safe checkpoint, returns whatever it completed, and refunds unused quota, including overage credits where applicable.


The Free tier gives you 500 requests per month at 1 req/min, with the same extraction quality as paid tiers. JS rendering, stealth mode, and all extraction features are included. The only things not on Free are T4 (CAPTCHA solving) and T5 (residential proxies), which are only needed for the hardest bot-protected sites.


On Free and Starter, you get a 429 QUOTA_EXCEEDED error. On Pro and Scale, you can purchase prepaid overage credits in advance and the API draws from that balance automatically. There's no surprise bill after the fact; if you have no credits, requests stop. Credits don't expire and are restored if you cancel and re-subscribe.


Competitors price by credits, where a single JS-rendered request can cost 5-75 credits. Runo charges flat per-request: JS rendering, stealth headless, and LLM-typed extraction are all in the base price. At the Scale tier, Runo works out to $0.90 per 1,000 effective requests versus around $6 for the nearest Firecrawl equivalent.


P50 latency is around 10-14s for the happy path (plain fetch plus LLM extraction). Pages requiring headless rendering add a few seconds. The worst case, a full headless render on a blocked site, can reach around 23s at P50. Async batch jobs trade latency for cost.


A few things to try: add a "hint" to the field to direct the extraction; check that your "type" matches what's on the page (a price shown as "$29" needs float, not string); try render_js: "always" if the page is JS-heavy. If nulls persist across retries, the data may be in an image. The process_images: true option (Scale only) runs a vision pass over scored image candidates to fill remaining nulls.


None. One 'POST' request with a JSON body, one JSON response.


Yes, we consider refund requests on a case-by-case basis. If you think you're owed a refund, email care@scrapewithruno.com with your request and reason, your payment receipt or order confirmation, and a description of the situation. We'll review it promptly and let you know whether a refund is possible.


GET STARTED

Stop parsing HTML. Start shipping.

No credit card required. Set up in under 5 minutes.

✓ 500 free requests/mo.

✓ Ready in minutes.

✓ Scales with your usage.

✓ Cancel anytime.