Cointelegraph Scraper

Cointelegraph publishes more crypto stories per day than almost anyone, which makes it the widest net for coverage and the hardest feed to read by hand. This Actor turns it into structured records: headline, summary, author, categories and a real ISO 8601 timestamp, each tagged with the assets the story actually names so volume becomes something you can filter.

What it does

• Covers the broadest daily story volume in crypto, which is what you want when the question is "did anyone write about this" rather than "what does one desk think".
• Tags which assets each story is about in mentionedTickers, resolved against a live CoinGecko coin list and the SEC company ticker file rather than a hardcoded table, with a guard so an ordinary word like "optimism" does not ship OP as a mention.
• Converts the feed's RFC 822 date to a real ISO 8601 datePublished, so stories sort and filter correctly instead of arriving as "Sat, 06 Sep 2026 05:30:00 GMT" strings.
• Returns the summary body in articleBody, decoded from the feed's HTML entities, so a headline arrives with enough context to classify without a second fetch.
• Carries the feed's own guid, so a scheduled run can drop stories it has already seen instead of reprocessing the whole feed.

Use cases

You need to	How this Actor does it
Filter high volume down to what matters	Keep only stories whose mentionedTickers intersect your watchlist
Catch a narrative early	Schedule the run hourly and group new guid values by ticker
Track coverage of an altcoin	Filter mentionedTickers on the asset and count stories per day
Feed a research agent	Call the Actor over MCP and let the model read the day's stories
Deduplicate a feed	Key your store on guid and only process what is new
Join news to prices	Run the CoinGecko or CoinMarketCap Actor on the same schedule and match on ticker

Quick start

1. Click Try for free.
2. Leave Feeds on all. Cointelegraph publishes a single feed covering the whole newsroom.
3. Set Articles per feed to control how many stories come back.
4. Click Start. Rows appear within seconds.
5. Export as JSON, CSV, Excel or XML, or read the dataset over the API.

Input

Field	Type	Default	What it controls
feeds	array	all	Which Cointelegraph feed to read. It publishes one, so all is the whole newsroom
articlesPerFeed	integer	50	How many stories each feed returns, counted from the newest
maxItems	integer	0	Caps how many records are written. 0 writes them all

{
    "articlesPerFeed": 50,
    "maxItems": 0
}

Output

One dataset item per story. Fields the feed does not carry for a story are dropped rather than returned as null, so a story with no byline carries no author.

Field group	Fields
Story	status, headline, articleBody, url, guid
Attribution	publisher, author, categories, feed
Assets	mentionedTickers
Timing	datePublished, scrapedAt

{
    "status": "ok",
    "headline": "Ethereum staking withdrawals hit record as validators rotate",
    "articleBody": "Validator exit queues cleared their largest volume to date, with analysts attributing the rotation to restaking yields rather than an exit from the asset.",
    "publisher": "Cointelegraph",
    "author": "Zoltan Vardai",
    "categories": [
        "Ethereum",
        "Markets"
    ],
    "feed": "all",
    "mentionedTickers": [
        "ETH"
    ],
    "datePublished": "2026-09-06T05:30:00.000Z",
    "scrapedAt": "2026-09-06T06:02:11.418Z",
    "url": "https://cointelegraph.com/news/ethereum-staking-withdrawals-record"
}

Integrations

Run it over the API and get the rows back in one call:

curl -X POST "https://api.apify.com/v2/acts/publicmoney~cointelegraph-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"articlesPerFeed": 50, "maxItems": 0}'

From Python:

from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("publicmoney/cointelegraph-scraper").call(run_input={"articlesPerFeed": 50, "maxItems": 0})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["headline"])

Give an AI agent the Actor over MCP:

{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?actors=publicmoney/cointelegraph-scraper"
        }
    }
}

Schedules run it on any cron, webhooks fire when a run finishes, and platform integrations push the dataset to Google Sheets, Slack, Airtable, Zapier or your own endpoint.

Cost

Pay per event, so you pay for records rather than compute time.

Event	Free tier	Top volume tier
News article	$0.002	$0.0007
Actor start	$0.00005 per GB	Same

A record that returned no data is published as a failure row and is never charged. Six volume tiers apply, so the per-record price falls with monthly volume.

Troubleshooting

Issue	Solution
Every story returns failed	Cointelegraph's feed was unreachable on that run. It is a public endpoint, so this is usually transient. Check the log and rerun.
I get far more stories than I can use	That is the point of this source. Lower Articles per feed, or filter on mentionedTickers and categories after the run.
mentionedTickers is empty on a story that clearly names an asset	The ticker index is resolved live and a story that names a company only in prose, with no cashtag and no bracketed symbol, will not match. An index that fails to load leaves the field empty rather than failing the run, so check the log.
A scheduled run returns stories I already have	The feed carries a rolling window, so each run sees recent stories again. Deduplicate on guid, which is stable per story.
articleBody is a summary, not the full article	That is what the feed publishes. This Actor does not fetch the article page, so you get the headline, the summary and the link.

FAQ

Does Cointelegraph have an API?

No public API for its newsroom. It publishes a syndication feed, which is what this Actor reads.

How far back does the feed go?

As far as Cointelegraph's feed window, which is the recent stories rather than the archive. To build a history, schedule the Actor and accumulate the dataset, deduplicating on guid.

Which language does it return?

The English newsroom. Cointelegraph runs several language editions and this Actor reads the English feed.

How does it know which assets a story is about?

It resolves cashtags and bracketed symbols in the headline and body against a live CoinGecko coin list and the SEC company ticker file. Both are fetched per run rather than hardcoded, so new listings resolve without an Actor update, and there is a guard against common words that happen to be tickers.

Does it return the full article text?

No. It returns what the feed publishes: headline, summary body, author, categories, link and date. Fetching and republishing full articles is a copyright question, so the Actor gives you the metadata and the URL.

Do I need a Cointelegraph API key?

No. Cointelegraph publishes its feed openly and this Actor reads it, so there is no Cointelegraph credential anywhere. You need an Apify token to call the Actor over the API.

Can I get this data in Python?

Yes, with the apify-client package as shown above. It returns parsed JSON, so there is no HTML or response handling on your side.

Can I get the data into Excel or Google Sheets?

Yes. Export the dataset as XLSX or CSV, or connect the Google Sheets integration so each run appends to a sheet.

Can an AI agent call this Actor?

Yes. Add it to an MCP client with the config above and the model can request what it needs on its own. Every record is flat JSON with named fields, so no post-processing is needed.

Is it legal to scrape Cointelegraph?

This Actor reads Cointelegraph's own public feed, which the publisher publishes for syndication, and returns headline, summary, byline and link rather than full article text. Republishing the text of an article is a copyright question and is your responsibility, so take your own legal advice for how you use it.

Changelog

• 0.0.2 Added mentioned-ticker resolution against the live coin and SEC ticker indexes.
• 0.0.1 First release. Cointelegraph articles as structured records.

Feedback

Found a field Cointelegraph publishes that this Actor misses, or an input it rejects? Open an issue on the Issues tab with the input and what you expected. A daily test runs every Actor in the fleet against live sources, so parser fixes ship fast.