open-index/ccrawl-urls

Common Crawl URL Index

Every URL Common Crawl has seen, as a slim columnar table, ready to seed a crawler frontier

What is it?

This dataset is the URL-level index of Common Crawl, republished as clean Parquet. Common Crawl is a non-profit that crawls the web every month and freely publishes its archives. Each crawl ships a columnar URL index that lists every captured page with its host, fetch status, content type, detected language, and a pointer into the WARC archive that holds the raw response.

We take that index as it is and republish it shard for shard, with no aggregation, deduplication, filtering, or enrichment. The rows and their order match the source columnar parts one to one, so this is a faithful mirror that loads with the standard Hugging Face tools and reads directly from DuckDB.

Right now the index holds 1 crawl across 2,098,491,742 URLs in 161.7 GB of compressed Parquet, spanning 300 shards. New monthly crawls are added as Common Crawl releases them.

The URL index is the map of the crawl. Before you download a single WARC you can already answer questions like which hosts were captured, how many pages returned a 200, what languages and MIME types show up, and which domains dominate a crawl. It is the natural starting point for building a crawl frontier, sampling the web by host or language, or fetching just the pages you care about straight out of the WARC archives.

It is released under the Open Data Commons Attribution License (ODC-By) v1.0, the same license Common Crawl uses.

What is being released?

One source columnar part becomes one Parquet shard, under a directory named for its crawl. Common Crawl splits each crawl's URL index into 300 parts, so each crawl is 300 shards you can load one at a time or stream together.

data/
  CC-MAIN-2026-25/
    part-00000.parquet
    part-00001.parquet
    ...
    part-00299.parquet
  CC-MAIN-2026-21/
    part-00000.parquet
    ...
stats.csv                     one row per committed crawl

Each row is one captured URL. The warc_filename, warc_record_offset, and warc_record_length columns point at the exact bytes of the response in Common Crawl's WARC archives, so you can range-fetch the original page without downloading a whole WARC. stats.csv tracks every committed crawl with its shard count, row count, Parquet size, and commit timestamps, which makes it easy to see coverage at a glance and to estimate remaining work.

Breakdown by crawl

URLs per crawl, newest first.

  CC-MAIN-2026-25             ████████████████████  2.1B

How to download and use this dataset

Load one crawl, filter by host or status, or stream the whole thing. It is a standard Hugging Face Parquet layout, so it works with DuckDB, datasets, pandas, and huggingface_hub out of the box.

Using DuckDB

DuckDB reads Parquet directly from Hugging Face, no download step needed.

-- Top 20 hosts by captured pages in the latest crawl
SELECT url_host_registered_domain AS domain, count(*) AS pages
FROM read_parquet('hf://datasets/open-index/ccrawl-urls/data/CC-MAIN-2026-25/*.parquet')
GROUP BY domain
ORDER BY pages DESC
LIMIT 20;

-- Fetch-status distribution for one crawl
SELECT fetch_status, count(*) AS pages
FROM read_parquet('hf://datasets/open-index/ccrawl-urls/data/CC-MAIN-2026-25/*.parquet')
GROUP BY fetch_status
ORDER BY pages DESC;

-- Language mix across the whole index
SELECT content_languages AS lang, count(*) AS pages
FROM read_parquet('hf://datasets/open-index/ccrawl-urls/data/**/*.parquet')
WHERE content_languages IS NOT NULL
GROUP BY lang
ORDER BY pages DESC
LIMIT 20;

-- All English HTML pages on a single host, with WARC pointers to fetch them
SELECT url, warc_filename, warc_record_offset, warc_record_length
FROM read_parquet('hf://datasets/open-index/ccrawl-urls/data/CC-MAIN-2026-25/*.parquet')
WHERE url_host_registered_domain = 'wikipedia.org'
  AND content_languages LIKE '%eng%'
  AND content_mime_type = 'text/html'
  AND fetch_status = 200;

Using datasets

from datasets import load_dataset

# Stream every crawl without downloading everything
ds = load_dataset("open-index/ccrawl-urls", split="train", streaming=True)
for row in ds:
    print(row["url"], row["fetch_status"])

# Load a single crawl by name
ds = load_dataset("open-index/ccrawl-urls", name="CC-MAIN-2026-25", split="train", streaming=True)

Using huggingface_hub

from huggingface_hub import snapshot_download

# Download one crawl
snapshot_download(
    "open-index/ccrawl-urls",
    repo_type="dataset",
    local_dir="./ccrawl-urls/",
    allow_patterns="data/CC-MAIN-2026-25/*.parquet",
)

For faster downloads, install pip install huggingface_hub[hf_transfer] and set HF_HUB_ENABLE_HF_TRANSFER=1.

Using the CLI

# Download the first shard of the latest crawl
huggingface-cli download open-index/ccrawl-urls \
    --include "data/CC-MAIN-2026-25/part-00000.parquet" \
    --repo-type dataset --local-dir ./ccrawl-urls/

Dataset statistics

Crawl	Shards	URLs	Parquet Size	State
CC-MAIN-2026-25	300	2,098,491,742	161.7 GB	complete
Total	300	2,098,491,742	161.7 GB

How this dataset is built

The pipeline is a single Go binary that works one crawl at a time. It enumerates the crawl's columnar parts, projects the published columns out of each part with ranged HTTP reads, writes one Zstandard Parquet shard per part, and commits shards to the hub in batches, deleting each local file right after its commit so disk stays flat. The fetch, project, and commit stages run concurrently across a worker pool rather than as three separate global passes, so the elapsed figure below is end-to-end publish wall-clock for the crawl, not the sum of isolated phase timings.

Live numbers for the newest crawl CC-MAIN-2026-25:

• Input: 300 columnar source parts, each streamed and projected without downloading the whole part
• Output: 161.7 GB of Zstandard Parquet committed so far, out of 161.7 GB across the whole dataset
• Coverage: 300 / 300 shards
• URLs: 2,098,491,742 URLs
• Elapsed: 7h 47m of publish wall-clock, from the first shard commit to the latest
• Speed: 39 shards/hour, 269.9M URLs/hour
• Status: complete, every shard is on the hub

Each output shard keeps a projected subset of the source columns, so its Parquet size is smaller than the source part by design, and that gap is column projection plus compression rather than compression alone. The WARC pointer columns are kept intact so you can still range-fetch the original response.

Dataset card for Common Crawl URL Index

Dataset summary

A faithful Parquet mirror of Common Crawl's columnar URL index (cc-index-table, subset=warc). Each monthly crawl's index is republished shard for shard, in source order, with no aggregation or filtering. People use it for:

• Crawl frontiers - seed a crawler with real, recently seen URLs instead of guessing
• Web-scale sampling - draw pages by host, TLD, language, or MIME type
• Targeted WARC fetches - use the WARC pointers to pull just the responses you need
• Web measurement - study host coverage, status codes, and content types across crawls
• Retrieval and dedup pipelines - the SURT sort key and content digest are built in

Dataset structure

Data instances

One row is one captured URL:

{
  "url_surtkey": "org,wikipedia)/wiki/common_crawl",
  "url": "https://en.wikipedia.org/wiki/Common_Crawl",
  "url_host_name": "en.wikipedia.org",
  "url_host_registered_domain": "wikipedia.org",
  "url_host_tld": "org",
  "url_protocol": "https",
  "fetch_time": "2026-06-18T04:11:57Z",
  "fetch_status": 200,
  "fetch_redirect": null,
  "content_digest": "3I42H3S6NNFQ2MSVX7XZKYAYSCX5QBYJ",
  "content_mime_type": "text/html",
  "content_mime_detected": "text/html",
  "content_charset": "UTF-8",
  "content_languages": "eng",
  "content_truncated": null,
  "warc_filename": "crawl-data/CC-MAIN-2026-25/segments/.../warc/CC-MAIN-...warc.gz",
  "warc_record_offset": 812634789,
  "warc_record_length": 24518
}

Data fields

Columns are in source order. Types are the Parquet types written by the pipeline.

Column	Type	Description
url_surtkey	VARCHAR	SURT-canonical sort key for the URL, host reversed and path normalized
url	VARCHAR	the captured URL
url_host_name	VARCHAR	full host name
url_host_registered_domain	VARCHAR	registrable domain, one level below the public suffix
url_host_tld	VARCHAR	top-level domain
url_protocol	VARCHAR	scheme, http or https
fetch_time	TIMESTAMP	when the page was fetched, UTC
fetch_status	INTEGER	HTTP status code of the capture
fetch_redirect	VARCHAR	redirect target when the capture was a redirect, else null
content_digest	VARCHAR	content hash of the response body, for dedup
content_mime_type	VARCHAR	MIME type reported by the server
content_mime_detected	VARCHAR	MIME type detected by Common Crawl
content_charset	VARCHAR	character set of the response
content_languages	VARCHAR	detected language codes, comma separated
content_truncated	VARCHAR	reason the capture was truncated, if any
warc_filename	VARCHAR	path of the WARC file holding the response
warc_record_offset	INTEGER	byte offset of the record in the WARC file
warc_record_length	INTEGER	byte length of the record

Data splits

One named config per crawl, plus a default config that globs every crawl. Each loads its shards as a single train split.

# One crawl by config name
ds = load_dataset("open-index/ccrawl-urls", name="CC-MAIN-2026-25", split="train")

# A specific crawl by path
ds = load_dataset("open-index/ccrawl-urls", data_files="data/CC-MAIN-2026-25/*.parquet", split="train")

Dataset creation

Why we built this

Common Crawl's columnar index is one of the most useful public datasets on the web, but the official copy lives behind a Hive-partitioned S3 layout that is awkward to browse and needs AWS tooling to query. We republish it in a plain, readable Hugging Face layout so you can point DuckDB or datasets straight at it, load a single crawl by name, and stream without any special setup.

Source data

Everything comes from Common Crawl's cc-index columnar table, the subset=warc partition of each monthly crawl. Source format is Hive-partitioned Parquet on S3 and its HTTPS mirror, enumerated from each crawl's cc-index-table.paths.gz manifest.

Processing steps

The pipeline is written in Go. For each crawl:

1. Enumerate the crawl's columnar parts from cc-index-table.paths.gz
2. Skip parts already committed, checked against the hub so a restart resumes cleanly
3. Stream each source part with ranged HTTP reads, projecting the published columns
4. Write one Zstandard-compressed Parquet shard per part, preserving source row order
5. Commit finished shards in batches to Hugging Face, with stats.csv and this card
6. Delete each local shard right after its commit lands, so disk stays flat

The pipeline picks up where it left off: stats.csv and the shards already on the hub are the resume signal, and committed parts are skipped on restart. No filtering, deduplication, or content changes. The rows match Common Crawl's index exactly, shard for shard. All Parquet files use Zstandard compression.

Personal and sensitive information

The index describes public web pages: their URLs, hosts, and capture metadata. It does not contain page bodies. URLs can still carry personal information that site owners put in the open, and no scrubbing has been done. Treat URLs as public but potentially sensitive strings.

Considerations for using the data

Social impact

A readable, queryable URL index lowers the bar for web research, retrieval, and crawler building. Work that once needed an AWS account and Athena now runs from a laptop with DuckDB.

Biases

Common Crawl is a sample of the web, not the whole web. Its seed lists, crawl budget, and politeness rules shape what gets captured, and popular hosts are covered more densely than the long tail. The index inherits every one of those biases. We did not correct for them.

Known limitations

• Snapshot, not history. Each crawl is a point-in-time capture; a URL missing from one crawl may appear in another.
• Fetch status varies. Not every row is a 200. Redirects, 404s, and other statuses are all present, as captured.
• Detected fields are heuristics. content_languages and content_mime_detected come from Common Crawl's detectors and can be wrong.
• WARC pointers are crawl-specific. A warc_filename only resolves within its own crawl's archives.

Additional information

Licensing

Released under the Open Data Commons Attribution License (ODC-By) v1.0, the same terms Common Crawl publishes under. Please credit Common Crawl when you use this data.

Not affiliated with or endorsed by Common Crawl.

Thanks

All the data here comes from Common Crawl, which crawls the web and gives the archives away for free. None of this would exist without their work.

Contact

Questions, feedback, or issues, open a discussion on the Community tab.

Last updated: 2026-07-22 20:19 UTC