# Global News & Media Monitor (GDELT) (`scrapemint/global-news-media-monitor`) Actor

Monitor worldwide news coverage of any topic, brand or company across 100+ countries and languages using GDELT. Get matching articles with source country and language, or a coverage-volume timeline showing how much the media is talking about it. No API key.

- **URL**: https://apify.com/scrapemint/global-news-media-monitor.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** News, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Global News & Media Monitor (GDELT)

See what the world's media is saying about any topic, brand, company or event - across 100+ countries and languages - using [GDELT](https://www.gdeltproject.org), the global news monitoring project. No API key, no login, no browser.

### Two modes

**Matching articles** - a list of news articles mentioning your topic, each with:
- title and link
- the publishing domain
- **source country and language** (this is what sets GDELT apart - it sees coverage worldwide, not just one country's headlines)
- publication date and a lead image

**Coverage volume timeline** - how large a share of world news coverage mentioned your topic over time. Perfect for spotting when a story breaks or a crisis spikes.

### Example input

```json
{
    "queries": ["\"supply chain\""],
    "mode": "articles",
    "timespanDays": 7
}
````

- **queries** - topics, brands or phrases (wrap exact phrases in quotes)
- **mode** - articles or coverage timeline
- **timespanDays** - how far back to look
- **sourceCountry** - limit to one country's media ("UnitedStates", "Kenya", "Germany")
- **language** - limit to one language ("English", "Spanish")
- **advancedFilters** - power-user GDELT operators like `tone<-5` (only negative coverage)

### Who uses this

- **PR, comms and brand teams**: monitor coverage of your company and competitors worldwide, in every language, and catch negative stories early.
- **Risk and geopolitical analysts**: track how a country, conflict or supply-chain event is being reported across borders.
- **Journalists and researchers**: find international coverage and measure how much attention a story is getting.
- **Investor-relations and market teams**: watch media attention around a company or sector.

Complements our Google News Scraper (single-locale headlines) with worldwide, multi-language monitoring and volume analytics.

### Pricing

A small fee per row (one per article, or one per timeline point). Searches that match nothing are free note rows, and the first 2 rows of every run are free.

### Notes

- Source: GDELT DOC 2.0 API, which indexes online news worldwide. GDELT rate-limits requests, so this actor spaces them out; very large multi-topic runs take a little longer.
- Coverage is strongest for recent days; the timeline reflects share of monitored coverage, not raw article counts.

# Actor input Schema

## `queries` (type: `array`):

Topics, brands, companies or phrases to monitor, one per line ("supply chain", "Tesla recall"). Wrap multi-word phrases in quotes for an exact match (""electric vehicle""). Each runs its own search.

## `mode` (type: `string`):

Articles = a list of matching news articles. Coverage timeline = how much of world news coverage mentioned the topic over time (great for spotting spikes).

## `timespanDays` (type: `integer`):

How many days back to search. GDELT covers a rolling window; recent days have the fullest coverage.

## `sourceCountry` (type: `string`):

Optional: limit to media from one country, using GDELT's country name with no spaces ("UnitedStates", "UnitedKingdom", "Kenya", "Germany"). Leave empty for worldwide.

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

Optional: limit to one language ("English", "Spanish", "French", "German"). Leave empty for all languages.

## `advancedFilters` (type: `string`):

Optional: extra GDELT query operators appended to every search, e.g. "tone<-5" (negative coverage) or "domainis:bbc.co.uk". For power users; see the GDELT DOC 2.0 documentation.

## `maxPerQuery` (type: `integer`):

Articles mode only: how many articles to return per topic (GDELT returns up to 250 most recent).

## `maxRows` (type: `integer`):

Stop after this many rows in total.

## Actor input object example

```json
{
  "queries": [
    "\"supply chain\""
  ],
  "mode": "articles",
  "timespanDays": 7,
  "maxPerQuery": 75,
  "maxRows": 1000
}
```

# 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 = {
    "queries": [
        "\"supply chain\""
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/global-news-media-monitor").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 = { "queries": ["\"supply chain\""] }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/global-news-media-monitor").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 '{
  "queries": [
    "\\"supply chain\\""
  ]
}' |
apify call scrapemint/global-news-media-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Global News & Media Monitor (GDELT)",
        "description": "Monitor worldwide news coverage of any topic, brand or company across 100+ countries and languages using GDELT. Get matching articles with source country and language, or a coverage-volume timeline showing how much the media is talking about it. No API key.",
        "version": "0.1",
        "x-build-id": "IsOhmP2V4pHXzdVlU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~global-news-media-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-global-news-media-monitor",
                "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/scrapemint~global-news-media-monitor/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-global-news-media-monitor",
                "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/scrapemint~global-news-media-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-global-news-media-monitor",
                "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": {
                    "queries": {
                        "title": "Search topics",
                        "type": "array",
                        "description": "Topics, brands, companies or phrases to monitor, one per line (\"supply chain\", \"Tesla recall\"). Wrap multi-word phrases in quotes for an exact match (\"\\\"electric vehicle\\\"\"). Each runs its own search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "mode": {
                        "title": "What to return",
                        "enum": [
                            "articles",
                            "timeline"
                        ],
                        "type": "string",
                        "description": "Articles = a list of matching news articles. Coverage timeline = how much of world news coverage mentioned the topic over time (great for spotting spikes).",
                        "default": "articles"
                    },
                    "timespanDays": {
                        "title": "Look back (days)",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "How many days back to search. GDELT covers a rolling window; recent days have the fullest coverage.",
                        "default": 7
                    },
                    "sourceCountry": {
                        "title": "Source country",
                        "type": "string",
                        "description": "Optional: limit to media from one country, using GDELT's country name with no spaces (\"UnitedStates\", \"UnitedKingdom\", \"Kenya\", \"Germany\"). Leave empty for worldwide."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Optional: limit to one language (\"English\", \"Spanish\", \"French\", \"German\"). Leave empty for all languages."
                    },
                    "advancedFilters": {
                        "title": "Advanced GDELT filters",
                        "type": "string",
                        "description": "Optional: extra GDELT query operators appended to every search, e.g. \"tone<-5\" (negative coverage) or \"domainis:bbc.co.uk\". For power users; see the GDELT DOC 2.0 documentation."
                    },
                    "maxPerQuery": {
                        "title": "Articles per topic",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Articles mode only: how many articles to return per topic (GDELT returns up to 250 most recent).",
                        "default": 75
                    },
                    "maxRows": {
                        "title": "Max rows",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Stop after this many rows in total.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
