Skip to content

Notion Scraper API: Public Notion Data, Parsed and Structured

Notion pages are rendered client-side, and some of what teams want to track — pricing tiers, template gallery additions, public notion.site workspaces — changes without a stable feed.

OUTPUT FORMATSHTMLJSONMarkdown

A hosted scraping API lets you send a URL and receive rendered output without maintaining a headless browser fleet or proxy pool yourself. This page explains what such an API can return from public Notion pages, which request inputs control that output, and how the credit and plan model works so you can size a job before building it.

What you can collect from public Notion pages

The useful way to plan a Notion collection job is to start from the consumer of the data, not from the page. Three consumers cover most work, and each implies a different output shape and update cadence.

A search index or research corpus. When the goal is to make published notion.site workspaces findable or analyzable, you want the page body as clean text or Markdown rather than raw HTML. The fields that matter are the page title and its content blocks; the cadence is usually a crawl followed by periodic refreshes.

A change feed. When the goal is to notice new template gallery entries, you care about what appeared since the last run. The useful fields are the template's title, creator, category, and price, and the job is a diff against the previous snapshot rather than a full re-collection.

A price and feature diff. When the goal is to watch Notion's own product and pricing pages, the output is most useful as named fields — tier name, price, included features — so a change is a row-level comparison rather than a page-level eyeball.

A single request can return page title, content blocks, pricing tiers, and feature lists together, so you do not need a separate integration per job. What changes between jobs is the output format and the extraction rule, not the transport.

Request inputs and what each one changes

The API takes a target URL plus an API key. Beyond that, a small set of parameters covers most Notion jobs. Treat this as a field map: pick the minimum set that gets you the output you need, because each option can change the credit cost of a request.

  • render_js — executes the page's JavaScript before returning content. Notion pages are client-rendered, so this is the option that makes page content visible in the response.
  • stealth_proxy — routes the request through a stealth proxy for pages that challenge automated traffic. Use it when a plain request is blocked, not by default.
  • country_code — routes through a residential IP in the named country. Use it when the page varies by geography.
  • extract_rules — CSS selectors (or XPath) mapped to field names. Use it when you know the page structure and want deterministic fields.
  • ai_extract_rules — a natural-language specification of the fields you want. Use it when the page structure is unstable or you would rather describe the output than maintain selectors.
  • Screenshot capture — returns a full-page image of the rendered page. Use it for visual documentation or when you need to prove what a page looked like at a point in time.

A practical default for a first request is render_js on, no stealth proxy, and no extraction rules — you get rendered HTML and can inspect it before committing to a schema. Add extract_rules or ai_extract_rules once you know which fields you actually need, and add stealth_proxy or country_code only if the plain request fails or the content is geo-variant.

Choosing an output format

The same request can come back in several shapes. The right choice depends on what consumes the data next.

  • Parsed HTML. Good for inspection and for pipelines that already have an HTML parser. It is the most faithful representation of what the renderer saw.
  • Structured JSON via extract_rules. Good when the page structure is stable and you want named fields. You define the mapping; the API returns the values.
  • Structured JSON via ai_extract_rules. Good when the page structure shifts or when you want to describe fields in plain language. It trades some determinism for less selector maintenance.
  • Markdown. Good when the consumer is a language model, a documentation index, or a human-readable diff. It strips presentation and keeps content.
  • Screenshots. Good for visual records and for confirming that a rendered page matched expectations at a point in time.

If you are unsure, start with Markdown for content jobs and structured JSON for pricing or template jobs. Markdown is easier to diff across runs; structured JSON is easier to load into a table.

Worked example: watching a Notion pricing page for tier changes

Suppose you want to know when a Notion pricing tier changes. The job is small but recurring, and the output should be comparable run to run.

Step 1 — pick the target. Use the public pricing page URL. If the page is geo-variant, add country_code for the market you care about.

Step 2 — render. Enable render_js so the tier cards are present in the response. Without it, you may receive a shell page.

Step 3 — extract. Define extract_rules mapping the tier name, price, and included-feature list to fields, or use ai_extract_rules with a short natural-language spec if the card layout changes often. The response comes back as parsed JSON.

Step 4 — compare. Store the JSON per run and diff against the previous run. A changed price or a moved feature is the signal; an unchanged run is a no-op.

Step 5 — size the cost. Each successful request that enables JS rendering costs 5 API credits. If you also enable premium proxies, the cost rises to 10 credits without JS rendering or 25 with it. Stealth proxy requests cost 75 credits. A daily check with render_js only is therefore 5 credits per run; a monthly total is easy to compute from that.

This pattern generalizes to the template gallery (diff on new template IDs) and to public notion.site pages (diff on content blocks or Markdown).

Two different failure modes: concurrency vs. target throttling

It is easy to conflate two limits that behave differently.

The first is your plan's concurrency limit — the number of requests you can have in flight at the same time. This is a property of your account, not of Notion. If you exceed it, requests queue or are rejected by the API, and the fix is to reduce parallelism or move to a plan with more concurrent requests.

The second is target-side throttling. If Notion (or any target) sees an aggressive request pattern, it may slow or block responses regardless of your concurrency headroom. The fix here is to space out requests or use multiple sessions, not to buy more concurrency.

A third, separate issue is geo-variance: the page returns successfully but the content differs from what you expected because the request resolved in a different country. That is not a failure; it is a signal to set country_code deliberately.

Diagnosing which one you are hitting matters because the remedies are different. A 429-style response with plenty of concurrency headroom points at target throttling; a rejection while your in-flight count is at the plan ceiling points at concurrency.

Plans, credits, and concurrency

The plan table below lists every standard and enterprise tier with its monthly price, API credit allowance, concurrent request ceiling, and which features are included. Treat it as a reference to verify against current pricing before you commit. Pricing, credit validity, tax treatment, trial terms, and cancellation rules are set by the operator of this service and should be confirmed on the current pricing page or with sales before purchase; the figures shown here are illustrative of the published tiers and may change without notice. Where a free trial or starting credit allowance is offered, its duration, eligibility, and any card requirement are defined by the current terms rather than assumed from this page. Credit expiry and rollover rules likewise follow the operator's current policy, and VAT or other taxes may be added depending on your billing location. Cancellation and refund handling are governed by the applicable terms of service at the time of purchase. If any of these commercial details matter to your budget, treat them as open questions to resolve before committing rather than as fixed facts on this page. Two things to read carefully. First, requests start at 1 credit each, and options such as JS rendering, premium proxies, and stealth proxies raise the per-request cost. Second, concurrency is the number of simultaneous requests, not a monthly total — a plan with 25 concurrent requests can still process far more than 25 requests in a month. Use the table to shortlist a tier by concurrency first (that is the hard ceiling on parallelism) and by credit allowance second (that is the monthly volume budget after per-request costs are applied).

Setup path

The integration surface is deliberately small. Create an account to get an API key and starting credits. SDKs are published for several common languages, and plain cURL works too; check the current documentation for the exact list of supported SDKs and their versions before you build. Send a request with the target URL and your key; the API handles rendering and bot bypass and returns parsed HTML or structured JSON. Add advanced parameters only when the basic request is not enough. If you prefer not to write code, the same endpoint can be called from no-code automation tools such as n8n, and a request builder is available for constructing calls interactively.

Plan comparison (verify current pricing)
PlanPrice / monthAPI creditsConcurrent requestsPriority email supportDedicated account managerTeam management
Hobby$1975,00025Not includedNot includedNot included
Freelance$49250,00050Not includedNot includedNot included
Startup (Recommended)$991,000,000100Not includedNot includedNot included
Business$2493,000,000200IncludedIncludedIncluded
Business +$5998,000,000400IncludedIncludedIncluded
Enterprise 14$99914,000,000500IncludedIncludedIncluded
Enterprise 24$1,59924,000,000600IncludedIncludedIncluded
Enterprise 41 (Recommended)$2,39941,000,000700IncludedIncludedIncluded
Enterprise 69$3,59969,000,000800IncludedIncludedIncluded
Enterprise 120$5,799120,000,000900IncludedIncludedIncluded

JavaScript rendering, rotating and premium proxies, geotargeting, and screenshots/extraction rules are included on every plan. Tax treatment, credit expiry, and rollover rules are set by the operator and should be verified against current terms before purchase. Requests start at 1 credit each, with JS rendering at 5 credits, premium proxies at 10 (no JS) or 25 (with JS), and stealth proxy at 75.

Frequently asked questions

Do I need a Notion account to scrape public Notion pages?

No. You need an API key for the scraping service, not a Notion login. Sign up, get the key and starting credits, then send the public URL. The service handles rendering and bot bypass on its side.

Can I request a Notion page as seen from a specific country?

Yes. Set country_code on the request to route through a residential IP in that country. This matters when the page content varies by geography, for example regional pricing or localized feature lists.

Is there a per-target rate limit for Notion?

The API enforces concurrency limits per plan, not per-target rate limits. If Notion itself throttles an aggressive pattern, space out requests or use multiple sessions. Those are two separate constraints and the remedies differ.

How do I get structured JSON instead of HTML?

Pass extract_rules with CSS selectors mapped to field names, or use ai_extract_rules with a natural-language description of the fields. Either way the response comes back as parsed JSON.

Which languages can I use to call the API?

Any language that can make an HTTP request. Published SDKs cover Python, Node.js, Go, PHP, Ruby, and Java, and plain cURL works. Pick whatever your stack already uses.

How is a Notion scraping request priced?

Requests start at 1 credit. Enabling JS rendering makes each successful request 5 credits. Premium proxies cost 10 credits without JS rendering or 25 with it, and stealth proxy requests cost 75 credits. Plans begin at $19/month and include a monthly credit allowance. Credit expiry and rollover rules follow the operator's current policy and should be confirmed on the pricing page before you commit.