# Cointelegraph News Scraper (`constructive_calm/crypto-news-scraper`) Actor

Scrapes cryptocurrency news from Cointelegraph across 15 languages. Extracts titles, summaries, full article text, authors, categories, publication dates, view counts, and cover images.

- **URL**: https://apify.com/constructive\_calm/crypto-news-scraper.md
- **Developed by:** [Omar Eldeeb](https://apify.com/constructive_calm) (community)
- **Categories:** News, SEO tools, Automation
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $6.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Cointelegraph News Scraper

**Scrape cryptocurrency news articles from [Cointelegraph](https://cointelegraph.com)** across 15 languages. Extract titles, summaries, full article text, authors, categories, publication dates, view counts, and cover images — all in one JSON record per article, ready for analytics, LLM training, sentiment tracking, or news aggregation.

### What does Cointelegraph News Scraper do?

This Actor pulls structured article data directly from Cointelegraph's internal GraphQL API across every language edition (English, Turkish, German, Spanish, French, Italian, Japanese, Korean, Portuguese, Chinese, Arabic, Malay, Hindi, Taiwan, Russian). You can grab the **latest articles**, **search for a keyword**, or pull **thousands of articles** for batch analysis — with proxy rotation, scheduling, API access, webhooks, and dataset export baked in through the Apify platform.

### Why use Cointelegraph News Scraper?

- **Real-time crypto news feed** — trigger scheduled runs and POST new articles to your own API for sentiment analysis, AI summaries, or Slack alerts.
- **Multi-language market research** — compare how the same story is covered in CT's 15 language editions.
- **Full-text corpus for LLMs** — each record includes the complete article body, perfect for fine-tuning or RAG pipelines.
- **Fast and cheap** — direct GraphQL access (no browser rendering) means hundreds of articles in seconds.
- **Integration-ready** — JSON output works out of the box with Zapier, Make, n8n, or the Apify API.

### How to use Cointelegraph News Scraper

1. Click **Try for free** and sign in to Apify (or create a free account).
2. On the **Input** tab, pick your **Language**, enter a **Search query** (leave empty for the latest), and set **Article count**.
3. Toggle **Fetch full article text** and **Fetch view count** as needed.
4. Click **Save & Start**. Scraped articles appear live on the **Output** tab.
5. Download the results as JSON, CSV, or Excel, or consume them via the Apify API.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `language` | enum | `"en"` | One of 15 CT language codes (`en`, `tr`, `de`, `es`, `fr`, `it`, `jp`, `kr`, `br`, `cn`, `ar`, `my`, `in`, `tw`, `ru`) |
| `article_count` | integer | `10` | How many articles to scrape (min 5, max 100,000) |
| `search_query` | string | `""` | Search keyword — leave empty to get the latest articles |
| `fetch_full_text` | boolean | `true` | Include the full article body in each record |
| `fetch_views` | boolean | `true` | Include the view count in each record |
| `proxyConfiguration` | object | Apify Proxy enabled | Proxy settings; Apify Proxy is recommended |

Example input:

```json
{
    "language": "en",
    "article_count": 10,
    "search_query": "Bitcoin",
    "fetch_full_text": true,
    "fetch_views": true
}
````

### Output

Each scraped article is pushed to the run's dataset as one JSON record. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
    "id": "110589",
    "post_url": "https://cointelegraph.com/news/what-happened-in-crypto-today",
    "postTranslate": {
        "id": "803945",
        "title": "Here's what happened in crypto today",
        "avatar": "https://s3.cointelegraph.com/uploads/...",
        "published": "2026-04-17T15:14:01+01:00",
        "publishedHumanFormat": "2 hours ago",
        "leadText": "Need to know what happened in crypto today? ..."
    },
    "author": {
        "id": "87",
        "author_url": "https://cointelegraph.com/authors/cointelegraph",
        "innovationCircleUrl": null,
        "authorTranslates": [{ "id": "1035", "name": "Cointelegraph" }]
    },
    "category": {
        "id": "2",
        "category_url": "https://cointelegraph.com/tags/latest-news",
        "categoryTranslates": [{ "id": "67", "title": "Latest News" }]
    },
    "postBadge": {
        "id": "528",
        "label": "",
        "postBadgeTranslates": [{ "id": "12213", "title": "News" }]
    },
    "full_text": "Today in crypto, Bitcoin surged above $76,000...",
    "views": 317
}
```

### Data table

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Cointelegraph internal post ID |
| `post_url` | string | Direct URL to the article |
| `postTranslate.title` | string | Article headline (in selected language) |
| `postTranslate.leadText` | string | Article summary / dek |
| `postTranslate.avatar` | string | Cover image URL |
| `postTranslate.published` | ISO datetime | Publication timestamp |
| `postTranslate.publishedHumanFormat` | string | "2 hours ago" |
| `author` | object | Author ID, profile URL, and translated name(s) |
| `category` | object | Category ID, URL, and translated name(s) |
| `postBadge` | object | Badge (e.g. "News", "Opinion") |
| `full_text` | string | Full article body (only if `fetch_full_text=true`) |
| `views` | integer | View count (only if `fetch_views=true`) |

### Pricing

**$6.00 per 1,000 articles saved** (Pay-Per-Event). You only pay for articles pushed to the dataset — failed requests cost nothing. Typical runs:

- 100 articles ≈ **$0.60**
- 1,000 articles ≈ **$6.00**
- 10,000 articles ≈ **$60.00**

There's also a small Apify platform compute fee (usually well under $0.01 per 100 articles thanks to direct GraphQL access — no browser rendering needed).

### Tips and advanced options

- **Leave `search_query` empty** for the freshest latest-news feed.
- **Turn off `fetch_full_text`** if you only need headlines and metadata — it reduces output size ~10x.
- **Schedule hourly runs** with a named dataset to build a rolling news archive.
- **Use webhooks** to POST new articles to your own endpoint the moment they're scraped.
- **Pick the right language** — CT publishes different articles per edition, not just translations.

### FAQ, disclaimers, and support

**Is scraping Cointelegraph legal?** Scraping publicly accessible web content is generally legal, but you are responsible for respecting Cointelegraph's Terms of Service and not reusing copyrighted content in ways that infringe their rights. Use the data for research, analytics, or personal reading — not wholesale republication.

**Why do some articles have empty `full_text` or missing `views`?** Cointelegraph occasionally reposts or updates articles; some fields may be null in the API. The scraper faithfully returns whatever the API provides.

**Does it work on all 15 languages?** All 15 language codes are accepted. Some editions (`my` in particular) may return fewer articles if CT's language endpoint is temporarily limited.

**Bug reports and feature requests** — open an issue on the Actor's Issues tab.

# Actor input Schema

## `language` (type: `string`):

Select the language of the articles

## `article_count` (type: `integer`):

Maximum number of articles to scrape

## `search_query` (type: `string`):

Search term for articles (leave empty to get latest articles)

## `fetch_full_text` (type: `boolean`):

Check this to retrieve the full text of articles

## `fetch_views` (type: `boolean`):

Check this to retrieve the view count of articles

## `proxyConfiguration` (type: `object`):

Using a proxy is recommended for faster and more reliable results

## Actor input object example

```json
{
  "language": "en",
  "article_count": 10,
  "search_query": "",
  "fetch_full_text": true,
  "fetch_views": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing scraped Cointelegraph articles with titles, full text, authors, categories, and views

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("constructive_calm/crypto-news-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("constructive_calm/crypto-news-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call constructive_calm/crypto-news-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=constructive_calm/crypto-news-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cointelegraph News Scraper",
        "description": "Scrapes cryptocurrency news from Cointelegraph across 15 languages. Extracts titles, summaries, full article text, authors, categories, publication dates, view counts, and cover images.",
        "version": "1.0",
        "x-build-id": "0X2CRfsYJYQSrsxyM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/constructive_calm~crypto-news-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-constructive_calm-crypto-news-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/constructive_calm~crypto-news-scraper/runs": {
            "post": {
                "operationId": "runs-sync-constructive_calm-crypto-news-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/constructive_calm~crypto-news-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-constructive_calm-crypto-news-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "tr",
                            "de",
                            "es",
                            "fr",
                            "it",
                            "jp",
                            "kr",
                            "br",
                            "cn",
                            "ar",
                            "my",
                            "in",
                            "tw",
                            "ru"
                        ],
                        "type": "string",
                        "description": "Select the language of the articles",
                        "default": "en"
                    },
                    "article_count": {
                        "title": "Article count",
                        "minimum": 5,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of articles to scrape",
                        "default": 10
                    },
                    "search_query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Search term for articles (leave empty to get latest articles)",
                        "default": ""
                    },
                    "fetch_full_text": {
                        "title": "Fetch full article text",
                        "type": "boolean",
                        "description": "Check this to retrieve the full text of articles",
                        "default": true
                    },
                    "fetch_views": {
                        "title": "Fetch view count",
                        "type": "boolean",
                        "description": "Check this to retrieve the view count of articles",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Using a proxy is recommended for faster and more reliable results",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
