How many tokens is a web page?

The answer in numbers

How many tokens a page costs depends on what your agent reads. On the median page of the 170 we measured:

• HTML as served: 65,378 tokens[1 Oct 2026], what a plain fetch hands an agent before any cleaning.
• Markdown from Firecrawl: 3,520 tokens[1 Oct 2026].
• Markdown from Skryp: 1,800 tokens.
• Main text only: about 400 tokens, from a neutral cleaned copy that exists for 105 of the pages.

At an example price of $3 per million input tokens, reading 1,000 such pages costs about $196 as HTML, $10.56 as Firecrawl's Markdown and $5.40 as Skryp's. The price is an illustration; the ratios are what carries over to your model.

By page type

Global shop pages carry the heaviest HTML, a median of 347,746 tokens on the 7 that returned it[1 Oct 2026]. Documentation is heavy as HTML (135,013) yet among the shortest as Markdown (1,065 from Skryp). JavaScript apps are the reverse case: the HTML that arrives is a small shell, and the content appears only after scripts run, so a reader that does not render the page gets almost nothing of what a visitor sees.

How much smaller, page by page

Across the 122 pages where both counts exist, the HTML was a median 34 times larger than Skryp's Markdown. Listings and global shop pages shrank more than 100 times. On the 153 pages both services read, Skryp's Markdown was a median 0.6 times the length of Firecrawl's[1 Oct 2026], and smaller still on shop, listing and JavaScript-heavy pages.

PDFs are the exception. There is no HTML to compare, and the two services returned about the same length: on the five PDFs both read, Skryp's text was shorter on three and longer on two, a median ratio of 0.95. Both convert the whole document, so a PDF's token count is mostly the document itself.

Fewer tokens is not automatically better

Leaner output drops navigation, repeated menus and cookie banners, and occasionally something a reader needed. Over the same run, the median share of each page's main content that came back was 0.98 for Skryp and 1.00 for Firecrawl, and on documentation pages Firecrawl returned 23 of 23 usable pages to Skryp's 20[1 Oct 2026]. The main-text-only copy is smaller still, but it is a cleaned extract that can lose tables, code and lists.

Choose by the task. To answer questions from a page, lean Markdown is usually enough. To pull specific fields such as a price or a stock level, ask for those fields directly: Extract returns them as JSON, which is smaller than any whole-page format.

Count the tokens of your own page

This script counts one page both ways with the same tokenizer as the study. It ran as shown:

# Count a page's tokens as raw HTML and as Markdown from Skryp, with the same tokenizer the study used.
# pip install httpx tiktoken    export SKRYP_API_KEY=...
import os

import httpx
import tiktoken

URL = "https://docs.python.org/3/tutorial/controlflow.html"
API = os.environ.get("SKRYP_API_URL", "https://api.skryp.dev")
enc = tiktoken.get_encoding("cl100k_base")

html = httpx.get(URL, follow_redirects=True, timeout=30).text
page = httpx.post(
    f"{API}/v1/scrape",
    headers={"Authorization": f"Bearer {os.environ['SKRYP_API_KEY']}"},
    json={"url": URL, "formats": ["markdown"]},
    timeout=120,
).json()

html_tokens = len(enc.encode(html, disallowed_special=()))
md_tokens = len(enc.encode(page["markdown"], disallowed_special=()))
receipt = page["receipt"]
print(f"HTML as served:  {html_tokens:>7,} tokens")
print(f"Skryp Markdown:  {md_tokens:>7,} tokens  ({html_tokens / md_tokens:.0f}x smaller)")
credits = receipt["credits"]
print(f"Route {receipt['route']}, exit {receipt['egress']['country'].upper()}, cache {receipt['cache']}, "
      f"{credits} credit{'' if credits == 1 else 's'}")

HTML as served:   41,309 tokens
Skryp Markdown:    6,242 tokens  (7x smaller)
Route http:direct, exit ZA, cache miss, 1 credit

The Scrape API and the MCP scrape tool also return a tokens field with each page, so an agent can see the cost of what it read. To try a page without writing code, use URL to Markdown.

Method

• Pages: 170 public pages in ten groups: news articles, documentation, shop pages from South Africa and elsewhere, country-priced pages requested from several countries, listings and search results, JavaScript apps, bot-protected pages, PDFs, and 15 pages from websites we run. Those 15 are counted; their addresses are withheld.
• Markdown: one run through each service on 1 October 2026 from a South African connection, with each service's default output (Firecrawl's main-content Markdown, Skryp's lean Markdown). Medians cover each service's usable pages.
• Usable: the page's content was present and complete enough to answer from, judged against a reference copy of the page.
• HTML: one plain GET per address later the same day, with desktop Chrome headers and no JavaScript. Pages that were blocked, failed or were PDFs have no HTML count and are left out of that median.
• Main text: a full browser render cleaned with trafilatura, an open-source extractor that is neither service's converter.
• Tokens: cl100k_base, OpenAI's tokenizer for GPT-4-class models. Other models split text differently, so their counts differ; the ratios between formats hold up better than the absolute numbers.
• Data: download the CSV, one row per page with every count.

What this does not show

• It is one run, from one place, on one day. Pages change, and a different set of 170 would give different medians.
• It counts what each service returned at its default settings, not the best either can do with tuning.
• Token counts measure size, not quality. Completeness and the usable count above are the quality measures, and they favour Firecrawl slightly.
• Skryp ran this study on its own product. The data and the counting method are published so you can check them.