# GDELT News Search & Monitor – Global News, Only New (`far003/gdelt-news-monitor`) Actor Search worldwide news in 65 languages through GDELT: keywords, phrases, domain, country, language and tone filters. Scheduled, it delivers only the articles it has never delivered before. One clean JSON record per article. - **URL**: https://apify.com/far003/gdelt-news-monitor.md - **Developed by:** [Francesco Antonio Russo](https://apify.com/far003) (community) - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing $0.80 / 1,000 news articles 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 ## GDELT News Search & Monitor – Global News in 65 Languages, Only New Articles Search worldwide online news through the **GDELT DOC 2.0 API** and get one clean JSON record per article: headline, link, site, language, publisher country, the moment GDELT first saw it, the social image and the search that found it. No API key, no proxy, no browser. **Scheduled, it delivers only the articles it has never delivered before.** It remembers every article it hands over (in a key-value store whose name you choose), so the same article is never returned twice, across runs, across days and across the searches of one list. A run with nothing new delivers nothing and costs nothing. | | | |---|---| | **Source** | GDELT Project, DOC 2.0 API (`api.gdeltproject.org`), the last 3 months of online news in 65 languages, updated every 15 minutes | | **Search** | keywords, `"exact phrases"`, `(A OR B)`, `-excluded`, plus GDELT operators: `domain:` `sourcecountry:` `sourcelang:` `theme:` `tone<` `tone>` | | **Window** | "how far back" (`90min` to `3m`) or a start and end date; 3 months is GDELT's limit | | **Depth** | up to 10,000 articles per search: GDELT gives 250 per request, so the window is read in pieces (stated below) | | **Only new** | persistent memory per monitor name, first run can be a silent baseline, nothing delivered is charged twice | | **Order** | newest first (default), oldest first, relevance, most positive / most negative tone | | **Polite** | one request at a time, 5.5 seconds after each answer; when GDELT answers 429 the request is retried every 20-30 seconds for up to 8 minutes | | **Price** | **$0.0008 per article delivered** ($0.80 per 1,000). Searching, empty answers and errors are free | **Typical uses:** brand and competitor monitoring · PR and crisis alerts · news research and media analysis across countries and languages · feeding an LLM, a RAG pipeline or an AI agent with fresh headlines · daily or hourly digests to Slack, e-mail, Google Sheets. This Actor returns **headlines and links, not article text**: the text belongs to the publishers and GDELT does not carry it. ### Quick start 1. Write one or more searches in **Searches**, one per line. 2. Choose **How far back** (default `24h`) and **Max articles per search**. 3. Run. Schedule it: every later run delivers only what appeared since. ```json { "queries": ["\"artificial intelligence\" regulation", "domain:bbc.co.uk economy"], "timespan": "24h", "maxArticlesPerQuery": 20 } ``` ### Recipes **Brand alert, scheduled every hour** (first run only builds the baseline, so the first alert is a real one): ```json { "queries": ["\"Acme Corp\" -careers", "\"Acme Corp\" sourcelang:german"], "timespan": "3h", "maxArticlesPerQuery": 50, "firstRunDelivers": false, "monitorName": "acme" } ``` **What does the French press say about a topic over the last day** (a real run on 20 October 2026 with `"timespan": "6h"` returned 15 articles, from `radiofrance.fr`, `humanite.fr`, `laprovence.com`…): ```json { "queries": ["macron"], "sourceCountries": ["france"], "sourceLanguages": ["french"], "timespan": "24h", "maxArticlesPerQuery": 500, "onlyNew": false } ``` **Italian, Spanish or German press: write the keywords in English** (GDELT matches on its English translation of the article; a real run on 20 October 2026 with the search below returned 25 articles, 24 of them in Italian, from `dagospia.com` and others): ```json { "queries": ["\"artificial intelligence\""], "sourceCountries": ["italy"], "timespan": "24h", "maxArticlesPerQuery": 25, "onlyNew": false } ``` **Very negative coverage on named news sites, between two dates, most negative first** (a real run on 20 October 2026 delivered 11 articles from `bbc.co.uk` and `theguardian.com`: 3 for `economy`, 6 for `war`, 2 for `election`; very negative articles on two sites are few, so keep the search broad): ```json { "queries": ["economy tone<-5", "war tone<-5", "election tone<-5"], "domains": ["bbc.co.uk", "theguardian.com"], "startDate": "2026-10-01", "endDate": "2026-10-07", "sortBy": "ToneAsc", "maxArticlesPerQuery": 10, "onlyNew": false } ``` ### Searches: what you can write GDELT searches the headline and the text of the article. **Write the keywords in English, also to find articles in other languages** (see the FAQ). All words must appear (AND). Every word needs **at least 3 letters**: `"artificial intelligence"`, not `AI`. | You want | Write | |---|---| | a phrase | `"climate change"` | | either word | `(tesla OR spacex)` (OR needs parentheses; a bare `a OR b` is wrapped for you) | | leave a word out | `tesla -recall` | | one site | `domain:bbc.co.uk` | | one publisher country | `sourcecountry:france` (names without spaces: `unitedkingdom`; 2-letter codes are GDELT's FIPS codes, not ISO: Germany is `GM`) | | one language | `sourcelang:italian` | | a GDELT theme | `theme:ENV_CLIMATECHANGE` | | negative or positive coverage | `climate tone<-5` · `economy tone>5` | The fields **Only sources from these countries**, **languages**, **Only these sites** and **Never these sites** add the same operators to every search without writing them (several values mean "any of them"). ### Input | Field | Default | Meaning | |---|---|---| | `queries` | — | One search per line (see above). Up to 200; empty, duplicated (also `Airbus` and `airbus`) or malformed lines are skipped and listed under `ignoredQueries` in `SUMMARY` and in the log | | `timespan` | `24h` | `90min` (at least 15), `6h`, `24h`, `7d`, `2w`, `3m` (`m` = months, at most 3) | | `startDate`, `endDate` | — | Instead of `timespan`: **when `startDate` is set, `timespan` is not used** (the log and `SUMMARY` say so if you changed it). `2026-10-01` or `2026-10-01T08:00:00Z`, UTC unless a zone is given; a bare end date includes that whole day. Older than 3 months is cut to 3 months | | `maxArticlesPerQuery` | `100` | Articles delivered (and charged) per search, 1-10,000 | | `maxArticlesTotal` | `0` | 0 = no extra limit; otherwise stop the run after this many | | `sortBy` | `DateDesc` | `DateDesc`, `DateAsc`, `HybridRel` (relevance), `ToneDesc`, `ToneAsc` | | `onlyNew` | `true` | Remember delivered articles and never deliver or charge them again | | `firstRunDelivers` | `true` | `false`: the first run of a search only builds a baseline (free) and you get what appears afterwards | | `monitorName` | `default` | Runs with the same name share one memory (key-value store `gdelt-news-monitor-`) | | `sourceCountries`, `sourceLanguages`, `domains`, `excludeDomains` | — | Filters added to every search | | `timeoutSecs` | `90` | Per request; GDELT often needs 15-25 seconds to answer | ### Output One record per article. Whatever GDELT does not give is `null`; nothing is guessed. ```json { "title": "Volkswagen bet on Xpeng to save its China business . It not going to plan", "url": "https://www.asiaone.com/money/volkswagen-bet-xpeng-save-its-china-business-its-not-going-plan", "domain": "asiaone.com", "language": "English", "sourceCountry": "Singapore", "seenAt": "2026-10-20T09:00:00.000Z", "socialImage": "https://media.asiaone.com/sites/default/files/styles/article_top_image/public/original_images/Oct2026/volkswagen%20car.JPG?itok=1thYIN67", "query": "\"electric vehicles\" sourcelang:english", "citation": "Source: The GDELT Project (https://www.gdeltproject.org/)" } ``` (A real record, from a search for `"electric vehicles" sourcelang:english` over 24 hours on 20 October 2026.) | Field | Meaning | |---|---| | `title` | Headline as GDELT stores it. Its tokenizer sometimes puts spaces around punctuation (`7 %`, `497 . 82`) and the Actor leaves it as it is | | `url` | Link to the article on the publisher's site | | `domain` | Publisher domain | | `language` | Language of the article (`English`, `Italian`…) | | `sourceCountry` | Country of the **publisher**, not necessarily the country the article is about | | `seenAt` | When GDELT **first saw** the article, ISO 8601 UTC, in steps of 15 minutes. It is not the publication time: GDELT does not give that | | `socialImage` | The article's sharing image, when it has one | | `query` | The search of your list that found it (the first one, when several found it) | | `citation` | `Source: The GDELT Project (https://www.gdeltproject.org/)`, as GDELT's terms of use require, in every record | Besides the dataset, the **SUMMARY** record of the key-value store lists for every search: the exact text sent to GDELT, the window, requests made, articles read, delivered, skipped because already delivered, held back by a limit, warnings and the error text if the search failed. ### Only new: how it works - Every article you receive is remembered by a short fingerprint of its link (`www.`, `http`/`https`, `#fragment`, trailing slash, tracking parameters such as `utm_*` and `fbclid` ignored). The same story reached through two searches, or through a link with `?utm_source=`, is **one** article and is charged once. - The memory lives in a **named key-value store** (`gdelt-news-monitor-`), so it survives between runs. Use another `monitorName` for an independent schedule. Delete the store to start from zero. - Only what was **delivered** (or baselined) is remembered. If a limit stops the run (your spending limit, `maxArticlesPerQuery`, `maxArticlesTotal`), the rest stays new and arrives in the next run. - The first run is per search, not per monitor: a search the monitor has never run delivers what GDELT lists now (`firstRunDelivers: true`) or, with `firstRunDelivers: false`, silently remembers it as a baseline and delivers only what comes later. With `false`, adding a search to an existing list never floods you with its old articles. - An article nobody listed for 100 days is forgotten (GDELT itself keeps 3 months). The memory is capped at 50,000 articles. - Each run reads the window from the newest article backwards until the window is exhausted or your limit is filled, skipping the ones already delivered. Skipping is free but each 250 articles read is one request: **for a frequent schedule use a short window** (every hour: `3h`; every day: `2d`). - Widening the window later (`24h` → `7d`) on a search that already ran will deliver the older articles of the wider window once; they were never delivered. ### Speed and GDELT's limits: read this before you schedule - GDELT allows **one request every 5 seconds** per client. The Actor sends one request at a time and waits 5.5 seconds after each answer. - GDELT is slow: opening the connection alone takes about 15 seconds (measured on 19 October 2026), so a request takes **15-25 seconds** and there is no way around it. A search of up to 250 articles is one request. - GDELT returns **at most 250 articles per request**. For more, with newest-first or oldest-first order the window is read in pieces: each piece ends where the previous one stopped, nothing is lost or repeated, one request per 250 articles. With relevance or tone order a request cannot be continued: the window is cut into equal time slices and GDELT's best 250 of each slice are read (the order holds inside a slice, not across them; the SUMMARY says so). - **GDELT often answers 429 ("too many requests"), and it does so at random.** The Actor does not give up: it asks again after 20-30 seconds (a random wait, never less than 20 s, longer if GDELT sends a `Retry-After`) and keeps trying for **up to 8 minutes per request**, about 19 attempts. Waiting longer between attempts does not help (direct tests on 20 October 2026 with requests 60 s apart and 20 s apart gave about the same share of answers, one in three to one in five), so many short waits beat a few long ones. If a request is still refused after 8 minutes, that search fails with a clear message (nothing delivered, nothing charged, the next run tries it fresh); if **three searches in a row** fail like that, the run stops trying the rest (they are listed as skipped and the next run takes them) instead of waiting for hours. - **Measured on 20 October 2026** (one day, one ordinary home connection, 9 real runs, 18 searches, 85 requests to GDELT): **67 of the 85 requests (79 %) were answered 429** and every one of the 18 searches still delivered its articles (or an honest zero). It is the data of one day: on a quieter day there are fewer 429s, and GDELT's behaviour can change. - **How long does a run take?** One search with GDELT answering at once: **about 30 seconds** (28 s measured). With 429s in between, one search took 78 s, 236 s and 335 s in our runs (2, 6 and 7 refusals before the answer). Lists: 3 searches took 5.6 and 6.4 minutes, **6 searches took 22 minutes (32 refusals)**. Rule of thumb: **allow 4 minutes per search**, and more for searches that read several pages of 250 articles. A bad day can take longer: up to 8 minutes per search before it is given up. - **Set the run timeout to match** (Run options → Timeout): at least **4 minutes × the number of searches**, and 1 hour or more for lists of 10 searches or more. If the timeout comes first, the Actor stops 2.5 minutes before it, writes the `SUMMARY`, keeps what it delivered and lists the searches it did not reach as skipped; with `onlyNew` the next run takes them. - Moments with more than 250 matching articles sharing the same 15-minute stamp cannot be paged any further; the SUMMARY warns when it happens. ### Pricing One event, **`article`** ($0.0008): one article delivered to the dataset. No fee per run, none per search; an empty answer, a refused query, an error, an article skipped because it was already delivered and the silent baseline run all cost $0. The platform usage of the run is included, as with every pay-per-event Actor. If a run reaches your spending limit it stops delivering, keeps the rest as new for the next run, and says so in `SUMMARY`. | Use | Articles | Cost | |---|---|---| | 5 brand names, hourly, 10 new articles a day in total | ~300 / month | **~$0.24 / month** | | Daily digest of 20 topics, 40 new articles a day | ~1,200 / month | ~$0.96 / month | | One-off research: 3 topics × 1,000 articles | 3,000 | $2.40 | | Backfill: 10,000 articles of the last 3 months | 10,000 | $8.00 | Cost cap per run: `maxArticlesPerQuery × number of searches` (or `maxArticlesTotal`), and your own spending limit. ### FAQ **Is this the full text of the article?** No. GDELT indexes headlines, links and metadata; the text belongs to the publishers. Use the `url` with a crawler or a content extractor if you need it. **Why `seenAt` and not a publication date?** GDELT's article list gives the time it first saw the page (to the nearest 15 minutes). For fresh news it is within minutes of publication; for an old article first seen late, it can be later than the real date. The Actor does not guess. **Why fewer articles than I asked for?** Because GDELT has fewer: the window is short, the filters are narrow, or the query needs fewer words ("AI" is refused, GDELT wants 3 letters). The SUMMARY says how many articles were read and why the search ended. **What does a refused query look like?** GDELT answers with a plain sentence ("Your search contained a keyword that was too short."). The Actor reports it for that search, with a hint, at no cost, and carries on with the other searches. **Why did my Italian, Spanish or German search return nothing?** In our measurements GDELT finds articles in other languages through English keywords, and an original-language phrase finds nothing (we think because it searches an English translation of each article; GDELT does not say so on the search page). Measured on 20 October 2026, sent straight to GDELT without this Actor: `"intelligenza artificiale"` and `"Künstliche Intelligenz"` returned an empty list, while `"artificial intelligence" sourcecountry:italy` returned 250 articles, `"climate change" sourcelang:spanish` 163 and `"climate change" sourcecountry:germany` 80. Write the keywords in English and choose the country or language with the filters; the articles come back in their own language. Some scripts (for example Japanese) are refused by GDELT as "too short": the Actor reports it, at no cost. The Actor reports exactly what GDELT answers ("Nothing new matched") and does not guess; the SUMMARY shows the exact text sent. **How far back can I go?** 3 months. Older dates are cut to 3 months and the log says so. **Why only 6 articles for "Formula 1" in 12 hours?** Because that is what GDELT returned for that phrase in that window (measured on 20 October 2026, the Actor delivered every one of them). GDELT indexes a selection of the world's online news, not every page, so counts from it are a sample of coverage, not a census. **Why does `seenAt` sometimes fall 15 minutes after the end of my window?** GDELT works in 15-minute batches and its window edges are not exact to the minute: a window ending at 11:00 returned articles stamped 11:15 (seen on 19 October 2026). The Actor keeps what GDELT returns and does not trim it. **Does GDELT cover every outlet?** No. It monitors tens of thousands of online news sources worldwide, unevenly: large and national outlets are well covered, small local sites less. Treat counts as a sample of coverage, not a census. **Can I use it commercially?** GDELT's terms (checked on 20 October 2026 at gdeltproject.org/about.html) make the data available "for unlimited and unrestricted use for any academic, commercial, or governmental use of any kind without fee", and require that "any use or redistribution of the data must include a citation to the GDELT Project and a link to this website (https://www.gdeltproject.org/)". Every record carries that citation; keep it when you pass the data on. **Is this affiliated with GDELT?** No. It is an independent client of GDELT's public API. ### Use the output ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: process.env.APIFY_TOKEN }); const run = await client.actor('far003/gdelt-news-monitor').call({ queries: ['"electric vehicles" sourcelang:english'], timespan: '6h', monitorName: 'ev-news', }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); for (const article of items) console.log(article.seenAt, article.domain, article.title); ``` ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("far003/gdelt-news-monitor").call(run_input={ "queries": ['"electric vehicles" sourcelang:english'], "timespan": "6h", "monitorName": "ev-news", }) for article in client.dataset(run["defaultDatasetId"]).iterate_items(): print(article["seenAt"], article["domain"], article["title"]) ``` ### Scheduling and integrations Create a **Schedule** for the Actor (for example every hour with `timespan: "3h"`), keep the same `monitorName`, and add a **Webhook** or an integration (Slack, e-mail, Google Sheets, Make, Zapier, n8n) on "run succeeded": each run's dataset holds only the new articles, so an empty dataset means nothing new. The Actor also works as a tool for AI agents through the Apify MCP server. ### Attribution News data from [The GDELT Project](https://www.gdeltproject.org/). GDELT is a free, open platform for research and analysis of global society. This Actor is not endorsed by or affiliated with GDELT. # Actor input Schema ## `queries` (type: `array`): One GDELT search per line. Plain words must all appear; put phrases in quotes ("climate change"); group alternatives in parentheses ((tesla OR spacex)); exclude with a minus (-football). Every word needs at least 3 letters (write "artificial intelligence", not AI). Write the keywords in English even for articles in other languages (GDELT finds them that way; choose them with sourcecountry: or sourcelang:). GDELT operators work too: domain:bbc.co.uk · sourcecountry:france · sourcelang:italian · theme:ENV_CLIMATECHANGE · tone<-5 (negative) · tone>5 (positive). ## `timespan` (type: `string`): A number and a unit: 90min (at least 15 minutes), 6h, 24h, 7d, 2w, 3m (m = months, at most 3: GDELT keeps the last 3 months). Ignored when a start date is given. ## `startDate` (type: `string`): Instead of "how far back": 2026-10-01 or 2026-10-01T08:00:00Z (UTC unless a zone is given). Older than 3 months is cut to 3 months. ## `endDate` (type: `string`): Used with a start date, or alone to end the window earlier than now. A bare date such as 2026-10-05 includes that whole day (UTC). ## `maxArticlesPerQuery` (type: `integer`): Your cost cap per search (one article = one charged event). GDELT returns at most 250 articles per request: above 250 the window is read in pieces (each piece ends where the previous one stopped, newest first), one request (15-25 seconds, plus GDELT's 5-second pause) per 250 articles. With "only new", articles beyond the cap stay new for the next run. ## `maxArticlesTotal` (type: `integer`): 0 = no extra limit. Stops the run once this many articles were delivered, whatever the number of searches. ## `sortBy` (type: `string`): Newest first is the one for monitoring. Relevance and tone orders cannot be paged: above 250 articles the window is cut into time slices and the best 250 of each slice are read. ## `onlyNew` (type: `boolean`): Remembers every article it delivers (in a named key-value store, see "Memory name") and never delivers or charges it again, across runs and across searches. Off: every run returns everything GDELT lists. ## `firstRunDelivers` (type: `boolean`): On (default): the first run of a search returns what GDELT lists now, later runs only the additions. Off: the first run silently remembers the current articles as a baseline (free, nothing returned) and you get only what appears afterwards. ## `monitorName` (type: `string`): Runs with the same name share one memory (a key-value store named gdelt-news-monitor-). Use another name for an independent schedule. Letters, digits and dashes. ## `sourceCountries` (type: `array`): Country names without spaces are safest: france, germany, unitedkingdom, unitedstates. Two-letter codes are GDELT's FIPS codes, not ISO (Germany = GM, UK = UK). Several countries = any of them. ## `sourceLanguages` (type: `array`): english, italian, french, german, spanish, arabic, chinese… (or 3-letter codes: eng, ita). Several languages = any of them. ## `domains` (type: `array`): bbc.co.uk, theguardian.com… A site includes its subdomains. A full URL is shortened to its domain. ## `excludeDomains` (type: `array`): Sites whose articles you do not want. ## `timeoutSecs` (type: `integer`): 10-180. GDELT often needs 5-20 seconds to answer. ## Actor input object example ```json { "queries": [ "\"artificial intelligence\" regulation" ], "timespan": "24h", "maxArticlesPerQuery": 20, "maxArticlesTotal": 0, "sortBy": "DateDesc", "onlyNew": true, "firstRunDelivers": true, "monitorName": "default", "timeoutSecs": 90 } ``` # Actor output Schema ## `articles` (type: `string`): No description ## `summary` (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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "queries": [ "\"artificial intelligence\" regulation" ], "timespan": "24h", "maxArticlesPerQuery": 20, "monitorName": "default" }; // Run the Actor and wait for it to finish const run = await client.actor("far003/gdelt-news-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "queries": ["\"artificial intelligence\" regulation"], "timespan": "24h", "maxArticlesPerQuery": 20, "monitorName": "default", } # Run the Actor and wait for it to finish run = client.actor("far003/gdelt-news-monitor").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 '{ "queries": [ "\\"artificial intelligence\\" regulation" ], "timespan": "24h", "maxArticlesPerQuery": 20, "monitorName": "default" }' | apify call far003/gdelt-news-monitor --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,far003/gdelt-news-monitor" } } } ``` 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 ` 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/aN1YC1TJZFGnGIIYX/builds/dgLHVlXtPR6Hpk775/openapi.json