commoncrawl/host-index-testing-v2

Common Crawl Host Index v2

GitHub: https://github.com/commoncrawl/cc-host-index

Each crawl, we generate a Host Index, which aggregates information about each web hosted visited during the crawl. The information is aggregated from the Common Crawl columnar index, web graph, and raw crawler logs.

Quickstart

The dataset is Hive-partitioned on crawl (data/crawl=CC-MAIN-2025-18/*.parquet). Open the whole dataset once, then filter with WHERE crawl = '...': because crawl is a partition key, the query engine only reads the files for the crawls you ask for.

Using DuckDB

DuckDB can read directly from Hugging Face. Create a view over every crawl once per session:

$ duckdb
D CREATE VIEW ccindex AS
    SELECT * FROM read_parquet(
        'hf://datasets/commoncrawl/host-index-testing-v2/data/**/*.parquet',
        hive_partitioning = true,   -- exposes the `crawl` directory as a column
        union_by_name = true        -- tolerates the schema differences between some crawls
    );

This CREATE VIEW is slow (minutes, not seconds): DuckDB lists every file under data/ through the Hugging Face API and, because of union_by_name, reads the footer of each one to build the merged schema. You pay this once per session. To make it faster, narrow the glob to the crawls you need (e.g. data/crawl=CC-MAIN-2025-*/*.parquet), or drop union_by_name and stick to columns that exist in every crawl.

Then run as many queries as you like against it. Always filter on crawl, and on url_host_tld when you can — both prune the amount of data read.

Which crawls are available:

D SELECT DISTINCT crawl FROM ccindex ORDER BY crawl;

A single crawl:

D SELECT surt_host_name, fetch_200, hcrank10
  FROM ccindex
  WHERE crawl = 'CC-MAIN-2025-18'
  LIMIT 3;

Several crawls — crawl names sort chronologically, so range comparisons work too:

D SELECT crawl, count(*) AS hosts, sum(fetch_200) AS pages_200
  FROM ccindex
  WHERE crawl IN ('CC-MAIN-2025-13', 'CC-MAIN-2025-18')
  GROUP BY crawl ORDER BY crawl;

D SELECT crawl, count(*) FROM ccindex
  WHERE crawl >= 'CC-MAIN-2025-01'
  GROUP BY crawl ORDER BY crawl;

The crawl history of one host, across every crawl:

D SELECT crawl, fetch_200, fetch_3xx, fetch_4xx, fetch_redirPerm, nutch_unfetched_pct, hcrank10
  FROM ccindex
  WHERE url_host_tld = 'org' AND surt_host_name = 'org,commoncrawl'
  ORDER BY crawl;

Popular hosts in a crawl with mostly non-English content:

D SELECT surt_host_name, hcrank10, fetch_200, fetch_200_lote_pct
  FROM ccindex
  WHERE crawl = 'CC-MAIN-2025-18' AND fetch_200 >= 100 AND fetch_200_lote_pct > 50
  ORDER BY hcrank10 DESC
  LIMIT 20;

Notes:

• The view re-lists the files on every query. If you will hammer one crawl, materialize it instead: CREATE TABLE c2025_18 AS SELECT * FROM ccindex WHERE crawl = 'CC-MAIN-2025-18';
• If your DuckDB does not auto-load httpfs, run INSTALL httpfs; LOAD httpfs; first.

Using pyarrow

pyarrow.dataset understands the Hive partitioning natively and pushes the crawl filter down to the file listing:

import pyarrow.dataset as ds
from huggingface_hub import HfFileSystem

fs = HfFileSystem()
ccindex = ds.dataset(
    "datasets/commoncrawl/host-index-testing-v2/data",
    filesystem=fs, format="parquet", partitioning="hive",
)

crawl = ds.field("crawl")
tld = ds.field("url_host_tld")

# one crawl, one TLD
gov = ccindex.to_table(filter=(crawl == "CC-MAIN-2025-18") & (tld == "gov"))

# one host across all crawls
history = ccindex.to_table(
    filter=(tld == "org") & (ds.field("surt_host_name") == "org,commoncrawl"),
    columns=["crawl", "fetch_200", "fetch_3xx", "fetch_redirPerm", "hcrank10"],
).sort_by("crawl")

Pass columns= whenever you can: Parquet is columnar, so unread columns cost nothing.

Using the Hugging Face datasets library

"Streaming" mode (streaming=True) avoids downloading all of the parquet files up-front (see the datasets docs). Point data_dir at one crawl's partition; note that the crawl column comes from the directory name, so it does not appear in rows loaded this way.

>>> from datasets import load_dataset
>>> ds = load_dataset("commoncrawl/host-index-testing-v2",
...                   data_dir="data/crawl=CC-MAIN-2025-18", split="train", streaming=True)
>>> print(next(iter(ds)))
{'nutch_unfetched_pct': 0, 'fetch_other': 0, ...}

For multi-crawl work, prefer DuckDB or pyarrow above.

Use Cases

Example questions this index can answer

• What's our history of crawling a particular website, or group of websites?
• What popular websites have a lot of non-English content?
• What popular websites seem to have so little content that we might need to execute javascript to crawl them?

Example questions that we'll use to improve our crawl

• What's the full list of websites where more than half of the webpages are primarily not English?
• What popular websites end our crawls with most of their crawl budget left uncrawled?

Example questions that future versions of this host index can answer

• What websites have a lot of content in particular languages?
• What websites have a lot of content with particular Unicode scripts?

Examples

US Federal government websites in the *.gov domain (about 1,400 domains, y-axis scale is millions):

See all graphs from this dataset

commoncrawl.org fetch. You can see that we revamped our website in CC-2023-14, which caused a lot of permanent redirects to be crawled in the next few crawls:

See all graphs from this dataset

Python code examples

More examples of how to use this dataset with Python can be found at the Common Crawl Host Index GitHub repo.

Highlights of the Schema

• There is a Hive-style partition on crawl, which is a crawl name like CC-MAIN-2025-13.
• There is one row for every webhost in the web graph, even if we didn't crawl that website in that particular crawl
• The primary key is surt_host_name, which stores the URL in Sort-friendly URI Reordering Transform (SURT) format. For example, the URI commoncrawl.org -> becomes org,commoncrawl).
• There is also url_host_tld, which we recommend that you use whenever possible (eg org for commoncrawl.org) - it typically improves performance, significantly.
• There are counts of what we stored in our archive (warc, crawldiagnostics, robots)
• fetch_200, fetch_3xx, fetch_4xx, fetch_5xx, fetch_gone, fetch_notModified, fetch_other, fetch_redirPerm, fetch_redirTemp
• robots_200, robots_3xx, robots_4xx, robots_5xx, robots_gone, robots_notModified, robots_other, robots_redirPerm, robots_redirTemp
• There is ranking information from the web graph: harmonic centrality, page rank, and both normalized to a 0-10 scale
  • hcrank, prank, hcrank10, prank10
• There is a language summary (for now, just the count of languages other than English (LOTE))
  • fetch_200_lote, fetch_200_lote_pct
• For a subset of the numbers, there is a foo_pct (eg fetch3xx_pct) which can help you avoid doing math in SQL. It is an integer 0-100.
• There are raw numbers from our crawler logs, which also reveal the crawl budget and if we exhausted it
  • nutch_fetched, nutch_gone, nutch_notModified, nutch_numRecords, nutch_redirPerm, nutch_redirTemp, nutch_unfetched
  • nutch_fetched_pct, nutch_gone_pct, nutch_notModified_pct, nutch_redirPerm_pct, nutch_redirTemp_pct, nutch_unfetched_pct
• There is a size summary (average and median size (compressed))
  • warc_record_length_median, warc_record_length_av (will be renamed to _avg in v3)

The full schema is available here: athena_schema.v2.sql.

Known bugs

• Some of the partitions have a different schema from others, so you will get errors for some of the columns in some of the crawls. We recommend that you avoid using those crawls, and only use the columns you need.
• When the S3 bucket is under heavy use, AWS Athena will sometimes throw 503 errors. We have yet to figure out how to increase the retry limit.
• Hint: https://status.commoncrawl.org/ has graphs of S3 performance for the last day, week, and month.
• The sort order is a bit messed up, so database queries take more time than they should.

Expected changes in test v3

• warc_record_length_av will be renamed to _avg (that was a typo)
• more _pct columns
• count truncations: length, time, disconnect, unspecified
• addition of indegree and outdegree from the web graph
• improve language details to be more than only LOTE and LOTE_pct
  • content_language_top, content_language_top_pct
• add unicode block information, similar to languages
• prank10 needs its power law touched up (hcrank10 might change too)
• there's a sort problem that .com shards have a smattering of not-.com hosts. This hurts performance.
• add domain prank/hcrank
• CI running against S3
• robots_digest_count_distinct
• robots_digest (if there is exactly 1 robots digest)
• Summarize fetch_redirect: same surt, same surt host, other.

Contributing

We'd love to get testing and code contributions! Here are some clues:

• We'd love to hear if you tried it out, and what your comments are
• We'd love to have python examples using Athena, similar to duckdb
• We'd love to have more python examples
• Please use pyarrow whenever possible

Terms of Use

https://commoncrawl.org/terms-of-use