Sulat.com / Writing on AIThursday, November 19, 2026
Agents/19 November 2026

Perplexity’s Context API turns web pages into clean markdown for US$1 per 1,000 URLs

Perplexity says its new Context API reads a batch of URLs and returns markdown, HTML, links or query-matched passages for US$1 per 1,000 URLs. In Perplexity's own test, 92.3% of URLs returned usable content.

Glossy 3D Perplexity logo above a glass funnel that turns crumpled web pages into a neat stack of clean text sheets

At a glance

  • Perplexity's Context API takes a batch of URLs and returns each page as markdown, HTML, links or highlights, the passages closest to a query, with metadata and a status for every URL.
  • By default it serves a stored copy fetched in the last two days and otherwise fetches live; max_age_seconds set to 0 forces a live fetch, and cache_only never fetches live.
  • Perplexity says it returned usable content for 92.3% of 1,000 URLs, with 87.9% fact recall and 80.3% content precision, in its own test.
  • It costs US$1 per 1,000 URLs, billed only for ok and not_modified results, so failed URLs are free, and each request can carry 10 to 25 URLs depending on usage tier.

Perplexity has launched the Context API, an endpoint that takes a list of URLs and returns each page as clean markdown, raw HTML, a list of links or the passages that answer a question. It costs US$1 per 1,000 URLs, and URLs that fail aren’t billed. Perplexity says it returned usable content for 92.3% of the 1,000 URLs in its own test.

The Perplexity Developers account announced it on X on 18 November, and Perplexity’s blog post is dated 17 November. The X post says the Context API reads up to 10 URLs per call. The quickstart puts that limit at 10 for the lowest usage tier, with higher tiers allowed more. It follows the Monitor API Perplexity launched on 16 November.

What comes back

You choose the output with the formats field. Markdown is the default, and the page’s HTML, its links and highlights are the other three. Links come back as absolute URLs, without duplicates and in page order. Highlights are the passages of the page closest to a query you send, capped at 4,096 tokens per page with 1,024 as the default, and one query applies to every URL in the request. Perplexity’s blog calls them snippets. It says they’re the page’s original wording rather than a summary, so the model gets less text without losing the source’s phrasing.

To build the markdown, Perplexity says a model scores each block of a page as main content or boilerplate and keeps only the content blocks. Every successful result also carries metadata such as the title, description, language, author and published date, plus the page’s Open Graph tags. An empty formats list returns the metadata alone.

Perplexity’s docs show all four formats in one call:

curl --fail-with-body --max-time 90 https://api.perplexity.ai/v1/context \
  -H "Authorization: Bearer $PERPLEXITY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": ["https://info.cern.ch/hypertext/WWW/TheProject.html"],
    "formats": ["markdown", "html", "links", "highlights"],
    "highlights": {
      "query": "What is the World Wide Web project?",
      "max_tokens_per_url": 128
    }
  }'

The Python SDK needs perplexityai 0.48.0 or later, and the TypeScript SDK needs @perplexity-ai/perplexity_ai 0.43.0 or later.

Fresh or stored

By default the API returns a stored copy of a page if it was fetched in the last two days, and fetches the page live if it wasn’t. A stored copy comes back without the site being contacted, so the result can’t fail because the site is slow or down. Setting max_age_seconds to 0 forces a live fetch, which the blog suggests for prices, scores and breaking news. The ceiling is 63,072,000 seconds, or two years. Setting cache_only to true never triggers a live fetch, and a URL with no stored copy recent enough comes back as no_content. Each result’s metadata says whether it was cached or live, and when it was fetched.

Three freshness modes: default uses a copy under two days old, max_age_seconds 0 reads live, cache_only never fetches live
One setting decides whether you get a stored copy or the page as it is now.

For repeat checks, if_modified_since takes the last_modified value from an earlier response. It works on one URL at a time with max_age_seconds at 0, and an unchanged page comes back as not_modified with no content. A not_modified result is billed like an ok one. The timeout_ms field sets how long each URL gets, from 1,000 to 110,000 milliseconds with 30,000 as the default. URLs are fetched in parallel, so one slow page doesn’t use up the time of the others.

Limits and failures

Usage tierRequests per secondURLs per request
Tier 0110
Tiers 1 to 3315
Tiers 4 and 5525
Source: Perplexity’s Context API quickstart.

Each request counts as one unit against the rate limit however many URLs it carries. The docs say a raised limit can reach 50 URLs per request, and a request body can’t be over 512 KiB.

A request returns HTTP 200 even when some or all of its URLs fail, so each result carries its own status type. The values are ok, not_modified, invalid_url, blocked, bot_challenge, crawl_failed, crawl_timeout, no_text, no_content and internal_error. Perplexity’s blog says to check the status before using the content, and to retry only the URLs that timed out. A 500, 502, 503 or 504 response returns no results at all, including pages that had finished.

Perplexity’s test

Perplexity tested the Context API on 1,000 URLs sampled from real agent fetch requests. The set covers 715 sites, including government and academic sources and non-English pages. A separate judge model scored the outputs.

Usable is the share of URLs that came back with the page’s real content rather than an error page or an empty result. Fact recall is the share of a page’s key facts, collected by the judge, that an output contains. Content precision is the share of returned text that’s page content, not cookie notices, navigation or ads. A failed fetch scores zero on the last two.

The Context API scored 92.3% on usable, 87.9% on fact recall and 80.3% on content precision. Perplexity ran the test itself. The X thread says the test used thousands of URLs, while the blog says 1,000.

Stat cards: 92.3% usable, 87.9% fact recall, 80.3% content precision, tested on 1,000 URLs from 715 sites
All three scores come from Perplexity’s own 1,000-URL test.

What it costs

The Context API costs US$1 per 1,000 fetched URLs, or US$0.001 each, with no token billing. The pricing page bills a URL when its status is ok or not_modified, whatever formats the request asks for, so a highlights-only or metadata-only request costs the same as full markdown. Invalid, blocked, empty and timed-out URLs are free. A request for 15 URLs, the Tier 1 maximum, costs US$0.015 if every page comes back ok. Each response has a usage object with the billed URL count and a list-price cost, which the docs say isn’t the amount invoiced.

Billing split: ok and not_modified cost US$0.001 per URL; every other status, such as blocked or crawl_timeout, is free
Only URLs that come back ok or not_modified cost anything.

The docs say the Context API reads pages you already have URLs for. To find pages for a query they point to the Search API, and for a generated answer with citations they point to the Agent API. The blog lists four uses: API integrations, price comparisons, policy questions and multi-source research. The quickstart has Python, TypeScript and cURL examples, the API reference lists every field, and the API Console has an interactive playground.


Discover more from Sulat AI & Tech News

Subscribe to get the latest posts sent to your email.