# Cloudflare Radar — Internet Traffic, DNS, BGP & DDoS Trends (`gochujang/cloudflare-radar-tracker`) Actor

Fetch global internet traffic trends, DNS query stats, BGP routing data, and HTTP protocol adoption from Cloudflare Radar's public API. Track top ASNs, country-level traffic patterns, outage detection, and Layer 3/4 DDoS attack trends. No API key required for basic endpoints.

- **URL**: https://apify.com/gochujang/cloudflare-radar-tracker.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 item trackeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Cloudflare Radar Tracker do?

**Cloudflare Radar Tracker** fetches global **internet traffic data**, BGP routing events, DNS query statistics, HTTP protocol adoption metrics, and **DDoS attack trends** from the Cloudflare Radar public API and complementary sources (Cloudflare Status, RIPE NCC Stat). Run it with no configuration to get Cloudflare outage and incident data immediately, or add a free Cloudflare API token to unlock device split ratios, protocol adoption percentages, top queried domains, and BGP route leak events — all filterable by country and time window.

### Why use Cloudflare Radar Tracker?

**A single structured feed for the internet's pulse — covering outages, protocol shifts, and routing anomalies that affect every connected business:**

- **Network operations and SRE alerting** — schedule hourly runs and trigger alerts when `traffic_anomalies` reports new Cloudflare incidents affecting your region, before your monitoring stack catches upstream latency degradation.
- **Protocol adoption benchmarking** — track HTTP/3 (QUIC) and HTTP/2 adoption curves over time by country to benchmark your own infrastructure against global **internet traffic data** trends and plan upgrade timelines.
- **BGP security and threat intelligence** — monitor BGP route leaks and hijack events from the `bgp_events` metric to detect routing anomalies that could affect your network reachability or third-party dependencies.
- **Traffic pattern research** — compare mobile vs. desktop HTTP traffic ratios across countries to inform CDN configuration, responsive design priorities, and regional product decisions.
- **DDoS trend monitoring** — the **DDoS attack trends** surfaced via Cloudflare Radar provide a global view of Layer 3/4 attack volume and target distribution, useful for threat modeling and insurance reporting.

### How to use Cloudflare Radar Tracker

1. Open the actor on Apify — it works immediately without any API key for outage and ASN data.
2. *(Optional but recommended)* Get a **free Cloudflare API token**: go to [dash.cloudflare.com](https://dash.cloudflare.com) → My Profile → API Tokens → Create Token → select the **Cloudflare Radar Read** template → copy the token.
3. Paste the token into the `cloudflareApiToken` input field to unlock enhanced metrics.
4. Set `dateRange` (`1d`, `7d`, `14d`, or `28d`) and optionally a `country` ISO code.
5. Select which `metrics` to fetch, or leave empty to fetch all available metrics.
6. Click **Run** — results appear in the dataset within seconds.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `dateRange` | string | `7d` | Time window: `1d`, `7d`, `14d`, or `28d` |
| `country` | string | (global) | ISO 2-letter country code, e.g. `US`, `DE`, `KR` — omit for global data |
| `metrics` | array | all core | Metric types to fetch (see table below) |
| `cloudflareApiToken` | string | (none) | Optional free Cloudflare API token for enhanced data |

**Available metrics and their auth requirements:**

| Metric | Source | API Token Required? |
|--------|--------|-------------------|
| `traffic_anomalies` | Cloudflare Status / Radar | No (fallback) / Yes (primary) |
| `device_split` | Cloudflare Radar v4 | Yes |
| `protocol_adoption` | Cloudflare Radar v4 | Yes |
| `top_domains` | Cloudflare Radar v4 | Yes |
| `bgp_events` | Cloudflare Radar v4 / RIPE NCC | Yes / No (fallback) |
| `top_asns` | RIPE NCC Stat API | No |

### Output

Each row represents one metric/data point. Mixed metric types are returned in the same dataset run:

```json
[
  {
    "report_type": "device_split",
    "metric": "mobile",
    "value": 62.4,
    "unit": "percent",
    "period": "7d",
    "country": "GLOBAL",
    "trend_7d": null,
    "fetched_at": "2026-09-02T05:00:00+00:00"
  },
  {
    "report_type": "traffic_anomalies",
    "metric": "incident",
    "name": "Cloudflare Workers Issues in Narita",
    "impact": "minor",
    "status": "resolved",
    "started_at": "2026-09-02T01:02:41.000Z",
    "resolved_at": "2026-09-02T02:24:25.688Z",
    "affected_components": ["Workers", "Asia - Tokyo, Japan - (NRT)"]
  }
]
```

### Data fields

| Field | Description |
|-------|-------------|
| `report_type` | Metric category: `device_split`, `traffic_anomalies`, `protocol_adoption`, `top_domains`, `bgp_events`, or `top_asns` |
| `metric` | Specific sub-metric within the report type (e.g. `mobile`, `incident`, `http3`) |
| `value` | Numeric value where applicable (null for categorical records) |
| `unit` | Unit of measurement (`percent`, `count`, etc.) |
| `period` | Time window of the data (`1d`, `7d`, `14d`, `28d`) |
| `country` | Country filter applied (`GLOBAL` if no country specified) |
| `fetched_at` | ISO 8601 timestamp of when the data was fetched |
| `name` | Incident or domain name (for `traffic_anomalies` and `top_domains`) |
| `impact` | Severity for incidents: `minor`, `major`, `critical` |
| `status` | Incident status: `resolved`, `investigating`, `identified` |
| `asn` | Autonomous System Number (for `top_asns` and `bgp_events`) |
| `holder` | ASN owner name (for `top_asns`) |

### Cost estimation

| Scenario | Rows returned | Estimated Cost |
|----------|--------------|---------------|
| Outage monitoring only (no token) | 5–20 | $0.03–$0.10 |
| All 6 metrics, 7-day window | 30–60 | $0.15–$0.30 |
| All metrics, 28-day window | 40–80 | $0.20–$0.40 |
| Daily scheduled run (all metrics) | ~50 rows/day | ~$0.25/day |

**Pricing**: **$0.005 per report row** returned (Pay-Per-Event).

No proxy required — all data sources are public APIs with generous rate limits. Cloudflare Radar API allows 100,000 requests/day on the free tier.

### FAQ

**Can I use this without a Cloudflare API token?**
Yes — without a token, the actor returns Cloudflare outage and incident data from the public `cloudflarestatus.com` API, plus BGP activity and ASN overview data from RIPE NCC. Adding a free Cloudflare token unlocks device split, protocol adoption, top domains, and enhanced BGP events.

**How do I filter for a specific country?**
Set the `country` field to a 2-letter ISO country code (e.g. `US`, `KR`, `DE`, `JP`). The `top_domains` and `device_split` metrics will then return country-specific data where available. `top_asns` data is always global.

**How current is the incident data?**
The `traffic_anomalies` feed reflects incidents from the past 30 days and is updated in near real-time by Cloudflare. For live alerting workflows, schedule the actor to run every hour and compare `started_at` timestamps to the previous run's output to detect new incidents.

***

**Disclaimer:** This actor is not affiliated with or endorsed by Cloudflare, Inc. or RIPE NCC. It accesses public APIs provided by these organizations under their respective terms of service. Cloudflare Radar data is subject to Cloudflare's API usage terms. Users are responsible for obtaining their own Cloudflare API token and complying with applicable rate limits and terms.

**Keywords:** Cloudflare Radar tracker, internet traffic data, DDoS attack trends, BGP routing events, protocol adoption, HTTP/3 monitoring, network outage detection, Cloudflare status, RIPE NCC, ASN overview

***

### Related actors

- [GitHub CI Monitor](https://apify.com/gochujang/github-ci-monitor) — DORA metrics for DevOps engineering teams alongside network reliability tracking
- [Docker Hub Image Tracker](https://apify.com/gochujang/docker-hub-tracker) — Container pull trends that correlate with internet infrastructure usage
- [npm Package Trends](https://apify.com/gochujang/npm-package-trends) — JavaScript package adoption tracking alongside HTTP protocol trends from Cloudflare

### Feedback

If this actor helps your infrastructure monitoring, a review helps others find it: [Leave a review on Apify Store](https://apify.com/gochujang/cloudflare-radar-tracker#reviews)

# Actor input Schema

## `dateRange` (type: `string`):

Time window for data (1d, 7d, 14d, 28d).

## `country` (type: `string`):

Filter by country (ISO 2-letter code, e.g. US, DE). Leave empty for global.

## `metrics` (type: `array`):

Which data types to retrieve.

## `cloudflareApiToken` (type: `string`):

Required. The Cloudflare Radar API rejects unauthenticated requests, so without a token this Actor returns nothing. Create one at dash.cloudflare.com with Radar read access.

## Actor input object example

```json
{
  "dateRange": "7d",
  "country": "",
  "metrics": [
    "traffic_anomalies",
    "device_split",
    "protocol_adoption",
    "top_domains"
  ]
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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("gochujang/cloudflare-radar-tracker").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("gochujang/cloudflare-radar-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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 gochujang/cloudflare-radar-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gochujang/cloudflare-radar-tracker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/bC4zrzttRu6hzuVx7/builds/NrdlQDkFCPUa6MSXV/openapi.json