# 📰 AI News Brief | Multi-Source Research Agent (`kay_abraham/news-intelligence-agent`) Actor

Plain English question in → cited intelligence brief out. Pulls Google News, RSS, Reddit, and Twitter. Routes tier-1 publishers to bypass paywalls. Claude analyses each article, flags anomalies, and corroborates across sources. Wikipedia grounds entities.  Built for analysts and policy teams.

- **URL**: https://apify.com/kay\_abraham/news-intelligence-agent.md
- **Developed by:** [Kirubel Abraham](https://apify.com/kay_abraham) (community)
- **Categories:** AI, News, Agents
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 intelligence brief delivereds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## News Intelligence Agent

Ask any news question in plain English. Get back a cited, multi-source, multi-language report.

This Actor reads the news for you and tells you what matters. You type a question, it does the research, you read the answer.

### What it does

You give it:
- A question like "What is happening with oil prices this week?"
- Your Anthropic Claude API key

It gives you:
- A short summary of the top findings
- The 5 most important headlines
- 3 to 7 themes grouping related articles together
- Any surprises or anomalies flagged
- A list of the people, companies, and countries most mentioned
- The overall mood (positive, neutral, negative, or mixed)
- 3 follow-up questions you might want to ask next
- A full markdown report ready to read or share
- The raw articles with summaries, keywords, and impact scores

All in the language you pick (English, Arabic, Chinese, Spanish, and 10 more).

### Who it is for

- Government and policy teams tracking global events
- Analysts who need a digest before a meeting
- PR and brand teams monitoring coverage
- Investor research on signals across markets
- Journalists tracking patterns across many sources
- Corporate strategy teams watching competitors and regulation

### How it works in 30 seconds

1. You type your question in plain English.
2. Claude reads the question, picks a balanced source set, and writes 3 to 8 search queries that cover the angle.
3. Apify discovers articles via Google News (with rag-web-browser as a fallback) and routes each URL to the right extractor: dedicated specialists for Bloomberg, Reuters, NYT, FT, Guardian, Al Jazeera; Smart Extractor for everything else.
4. Claude reads each article, decides if it is relevant, scores its impact, and pulls keywords, entities, and quotes.
5. Claude looks across all the articles, groups them into themes, flags anything surprising, and writes you a final brief.
6. You get the output as a structured dataset and a markdown report.

The whole thing takes 2 to 5 minutes. You do not have to pick sources, write search queries, or read 50 articles yourself. Claude does that.

### Quick start

1. Get an Anthropic API key at console.anthropic.com (starts with sk-ant-).
2. Open this Actor in the Apify Console.
3. Type your question in the Your question field.
4. Paste your Anthropic key in the Anthropic Claude API key field.
5. Paste your personal Apify API token in the "Apify API token" input field. Find it at Apify Console -> Settings -> Integrations -> Personal API tokens.
6. Click Start.

That is the entire setup. Every other field has a sensible default.

The Apify token is required because the runtime token issued to the Actor is scoped down and cannot call the child scrapers. Your personal token is used only during the run and is never reused elsewhere.

### Example questions

- What global events this week could materially affect Dubai's economy? Focus on oil, trade, tourism.
- How is the new EU AI regulation being covered across European and American press?
- What are competitors saying about supply chain disruption in semiconductors?
- Track misinformation patterns around the latest election in Country X.
- What is happening with central bank rate decisions in the last 7 days?

### Input fields

You only need to fill in three fields. Everything else is optional.

| Field | What it does | Default |
|---|---|---|
| Your question | Plain English. Be specific. | required |
| Anthropic API key | Starts with sk-ant-. Apify never stores it. | required |
| Apify API token | Used to call the child scrapers. Find at Apify Console -> Settings -> Integrations. | required |
| Use direct RSS feeds | Pulls articles directly from major publishers' RSS feeds in real time, removing the Google News indexing lag. | on |
| Include Reddit | Adds Reddit posts as a community sentiment signal. | off |
| Include Twitter / X | Adds tweets from verified accounts as a breaking-news signal. | off |
| Wikipedia enrichment | Fetches Wikipedia summaries for top entities so Claude can ground its analysis in factual context. | off |
| Claude model | Sonnet 4.6 is the default. Haiku is cheap and fast. Opus is thorough and slow. | Sonnet 4.6 |
| Output language | What language you want the final report in. 14 options. | English |
| Source selection mode | Auto lets Claude pick. Manual uses only your sources. Hybrid combines both. | Auto |
| Manual source list | Domains like bbc.com, reuters.com. Only used in manual or hybrid. | empty |
| Excluded sources | Domains to skip. | empty |
| Semantic tags | Extra keywords Claude should weigh higher. Example: OPEC, NATO. | empty |
| Country focus | ISO codes like US, CN, RU, SA, AE. Leave empty for global. | empty |
| Translate non-English articles | If on, Claude reads sources in any language. If off, only output-language sources. | on |
| Time window | Last 24 hours, 7 days, or 30 days. | 7 days |
| Research depth | Shallow (20 articles), medium (50), or deep (100). | medium |
| Max articles cap | Hard ceiling on articles analyzed. | 50 |
| Bypass paywalls | Uses Googlebot user-agent to access Bloomberg, FT, WSJ. | on |
| Custom instructions | Power users only. Extra guidance for Claude. | empty |
| Max Claude spend | Hard ceiling on token cost. The run stops cleanly if exceeded. | $5 |
| Analysis features | Toggles for keyword extraction, sentiment, entities, quotes, etc. | all on |
| Webhook URL | POSTs the markdown report to Slack, email, or any URL. | empty |

### What you get back

One record in your default Apify Dataset:

```json
{
  "userQuery": "your question",
  "outputLanguage": "English",
  "generatedAt": "2026-05-12T...",
  "executiveSummary": "3 to 5 bullet points",
  "topHeadlines": [{ "title": "...", "url": "...", "impactScore": 9, "oneLineWhy": "..." }],
  "themes": [{ "name": "...", "summary": "...", "articleUrls": [], "averageImpactScore": 7 }],
  "anomalies": [{ "headline": "...", "url": "...", "impactScore": 9, "why": "..." }],
  "keyActors": [{ "name": "OPEC", "type": "organization", "mentionCount": 12, "role": "..." }],
  "overallSentiment": { "summary": "negative", "breakdown": { ... }, "explanation": "..." },
  "relatedQuestions": ["follow-up 1", "follow-up 2", "follow-up 3"],
  "confidenceScore": 0.82,
  "confidenceReason": "Good coverage, recent sources, consistent themes",
  "articles": [
    {
      "title": "...",
      "url": "...",
      "source": "reuters.com",
      "publishedAt": "...",
      "language": "en",
      "summary": "...",
      "keywords": [],
      "entities": { "organizations": [], "countries": [], "people": [] },
      "sentiment": "negative",
      "impactScore": 8,
      "anomalyFlag": false,
      "quotes": []
    }
  ],
  "sourceCoverage": { "totalArticlesIncluded": 38, "uniqueSources": 14, "sources": [], "languageBreakdown": { "en": 28, "ar": 6, "zh": 4 } },
  "markdownReport": "the full readable brief in markdown",
  "costEstimateUsd": { "claudeTokens": 0.87, "totalSpentSoFar": 0.87 },
  "tokensUsed": { "input": 95000, "output": 12000 }
}
````

The markdown report has 8 sections in order: Executive Summary, Top Headlines, Themes, Anomalies, Key Actors, Overall Sentiment, Related Questions, Article Index.

### Cost

Pricing for this Actor is not finalized yet. It is in early access. The cost model below reflects only your underlying compute and Claude API spend during the beta period.

Two underlying bills today:

1. Apify platform compute, billed on your Apify account. Roughly $0.30 to $0.50 per typical run.
2. Anthropic Claude tokens, billed directly by Anthropic. Set your spending limit per run in the input. Defaults to $5 ceiling.

Typical run with Claude Sonnet 4.6:

- Shallow (20 articles): about $0.30 in Claude tokens
- Medium (50 articles): about $1.00 in Claude tokens
- Deep (100 articles): about $2.50 in Claude tokens

Claude Haiku 4.5 is 8 to 10 times cheaper. Claude Opus 4.7 is 5 times more expensive.

You pay Anthropic directly. The Actor does not mark up your Claude usage during the beta.

A pay-per-event price model will be added once the Actor leaves beta. Expected components:

- A small per-run start fee
- A per-article fee for each article that passes the relevance filter
- A per-digest fee for the final synthesized report

Final numbers and per-customer-tier discounts will be published before launch. If you want to lock in early-access pricing as a design partner, contact the maintainer via the Issues tab.

### Limits

- Some sites block automated access even with paywall bypass on. Document any consistent failures and we will look at it.
- Non-Latin language quality depends on Claude's training. Tested broadly on Arabic, Chinese, Russian, Japanese, Spanish, German, French.
- Runs are not real-time. Each run pulls fresh articles within the chosen time window.
- If your Anthropic balance is exhausted mid-run, the run fails cleanly with a clear message. Set spending limits in your Anthropic console.

### Tech stack under the hood

Discovery (Stage 2). Multi-channel, toggle what you need:

- data\_xplorer/google-news-scraper-fast as the primary discovery channel. Native news date filtering, returns decoded original article URLs. Always on.
- apify/rag-web-browser as a fallback when Google News returns thin results for a query.
- Direct RSS feeds (automation-lab/rss-feed-reader) from Reuters, BBC, AP, Bloomberg, FT, Guardian, NYT, WaPo, AlJazeera, CNN, CNBC, Politico. Real-time, removes Google News indexing lag. On by default.
- Reddit (trudax/reddit-scraper-lite). Opt-in via enableReddit. Community signal, sentiment.
- Twitter / X (apidojo/twitter-scraper-lite). Opt-in via enableTwitter. Breaking news 2-6 hours ahead of mainstream press.
- Wikipedia entity enrichment (automation-lab/wikipedia-scraper). Opt-in via enableWikipedia. Fetches 1-paragraph summaries for the most-mentioned organizations, people, and countries so Claude can ground its analysis in factual entity context.

Source-tier weighting in synthesis:

- Each article is automatically tagged Tier 1 (wire services and major publishers), Tier 2 (established regional and topic specialists), or Tier 3 (niche or blog).
- Stage 5 weights Tier 1 claims higher in corroboration. Social signal (Reddit, Twitter) is labelled "\[social signal]" rather than "\[single-source]" so the reader knows it's a leading indicator, not a confirmation.

Extraction (Stage 3): domain-aware routing.

Tier-1 publishers go to dedicated Store Actors that handle paywalls and bot defences. Cheerio-based generic extractors get blocked on these sites, so each gets its own specialist:

- nytimes.com -> xtracto/nytimes-scraper
- bloomberg.com -> xtracto/bloomberg-news-article-scraper
- reuters.com -> xtracto/reuters-scraper
- ft.com -> xtracto/ft-scraper
- theguardian.com -> xtracto/guardian-scraper
- aljazeera.com -> piotrv1001/aljazeera-scraper
- bbc.com / bbc.co.uk -> nexgendata/bbc-news-scraper

Everything else falls through to lukaskrivka/article-extractor-smart with apify/website-content-crawler as a last-resort fallback. Any URL that returns empty from a dedicated extractor is automatically retried through the Smart Extractor, so coverage never drops silently.

Brain (Stages 1, 4, 5):

- Anthropic Claude API for planning, per-article analysis, and final synthesis.

Three Claude pass groups per run: one to plan, one per article batch to analyze, one to synthesize. That is what makes this an agent, not just a wrapper.

### Troubleshooting

If a run finishes with fewer articles than expected, check the run log for these patterns:

- "exceed the memory limit" on a dedicated extractor. You are hitting the account-wide memory cap (8GB on Starter, 32GB on Scale). The Actor lowers parallelism and memory automatically in v0.2.4, but a heavy parallel load on your account from other Actors can still push you over. Wait for other runs to finish, or upgrade your Apify plan.
- "Insufficient permissions" or "LIMITED\_PERMISSIONS" on a child Actor. Your runtime token is scoped down. Two fixes: pass your personal Apify API token in the apifyToken input field, or restart the run from the Console UI and grant "Call other Actors" in the Run options dialog.
- "Request blocked - received 401 / 403" inside the rag-web-browser logs. This is expected for paywalled / cookie-walled sites. rag-web-browser still returns the URL even when it cannot fetch the content, so the URL is handed off to the right dedicated extractor in Stage 3.

### Support

Use the Issues tab on this Actor page to reach the maintainer.

# Actor input Schema

## `userQuery` (type: `string`):

Ask in plain English. Example: What is the new virus outbreak doing to global supply chains? Focus on shipping, manufacturing, and oil prices.

## `claudeApiKey` (type: `string`):

Your Anthropic API key (starts with sk-ant-). Get one at console.anthropic.com. Apify never stores it and never charges you for tokens. You pay Anthropic directly.

## `apifyToken` (type: `string`):

Paste your personal Apify API token here (Apify Console -> Settings -> Integrations -> Personal API tokens). The agent uses it to call its child scraper Actors (rag-web-browser, article-extractor-smart, the dedicated publisher extractors). The platform-issued runtime token is scoped down and these calls fail without your personal token. Apify never reuses this token outside of this run.

## `enableRss` (type: `boolean`):

When on, the agent pulls articles directly from major publishers' RSS feeds (Reuters, AP, BBC, Bloomberg, FT, Guardian, NYT, WaPo, AlJazeera, CNN, CNBC, Politico) in addition to Google News. RSS feeds publish immediately, removing the 1-3 hour Google News indexing lag. Recommended on for breaking news and live monitoring.

## `enableReddit` (type: `boolean`):

Pull relevant Reddit posts (via trudax/reddit-scraper-lite). Useful for sentiment, community signal, and topics that move on social before mainstream press. Adds ~$0.05 per run.

## `enableTwitter` (type: `boolean`):

Pull relevant tweets from the last N days (via apidojo/twitter-scraper-lite). Strong for breaking news that hits Twitter 2-6 hours before mainstream press. Adds ~$0.10 per run.

## `enableWikipedia` (type: `boolean`):

When on, the agent fetches Wikipedia summaries for the most-mentioned organizations, people, and countries in the article set. Claude uses this context in synthesis to ground its analysis in factual entity data. Adds ~$0.02 per run.

## `claudeModel` (type: `string`):

Sonnet is the default balance of quality and cost. Haiku is fastest and cheapest. Opus is most thorough but slowest and most expensive.

## `outputLanguage` (type: `string`):

Language of the final report. Articles are still pulled in their original language and translated for analysis if needed.

## `sourceMode` (type: `string`):

Auto: Claude picks a balanced source set for your topic. Manual: only the sources you list. Hybrid: Claude suggestions plus yours.

## `manualSources` (type: `array`):

Domains to include. Examples: bbc.com, reuters.com, ft.com, bloomberg.com, aljazeera.com. Only used in manual or hybrid mode.

## `excludeSources` (type: `array`):

Domains to skip even if Claude would otherwise suggest them.

## `tags` (type: `array`):

Extra keywords or entity names Claude should weigh when filtering. Example: OPEC, semiconductors, NATO. Articles mentioning these get boosted relevance.

## `countries` (type: `array`):

ISO codes of countries to focus on. Example: US, CN, RU, UK, FR, DE, JP, IN, SA, AE, IR. Leave empty for global.

## `translateToEnglish` (type: `boolean`):

If true, Claude reads non-English articles in their original language and produces analysis in your chosen output language. If false, only articles in your output language are considered.

## `timeWindow` (type: `string`):

How recent the articles should be. Pick a preset, or choose 'custom' and set dateFrom and dateTo below.

## `dateFrom` (type: `string`):

Only used if timeWindow is 'custom'. ISO format YYYY-MM-DD. Example: 2026-04-01.

## `dateTo` (type: `string`):

Only used if timeWindow is 'custom'. ISO format YYYY-MM-DD. Example: 2026-05-12.

## `depth` (type: `string`):

Shallow returns about 20 articles, medium about 50, deep about 100. Deeper means higher Claude token cost.

## `maxArticles` (type: `integer`):

Hard ceiling on articles to deeply analyze. Overrides depth if smaller.

## `bypassPaywalls` (type: `boolean`):

Uses Googlebot user-agent on the Smart Article Extractor to access sites like Bloomberg and FT. Costs slightly more compute.

## `customInstructions` (type: `string`):

Power users only. Extra guidance for Claude on top of your question. Example: Weight Reuters and BBC 2x. Ignore opinion pieces. Highlight any mention of central bank rate changes.

## `maxClaudeCost` (type: `number`):

Hard ceiling on Claude token spend. The run stops cleanly if Claude tokens would exceed this. Protects you from runaway prompts.

## `analysisFeatures` (type: `object`):

Toggle which per-article analyses run. Disabling reduces token cost. Default is everything on.

## `webhookUrl` (type: `string`):

If set, the final markdown report is POSTed to this URL. Useful for Slack, email automation, or any other system.

## `debugMode` (type: `boolean`):

If on, stores the raw Claude plan, the search queries used, and per-stage timing in the output dataset. Helpful when something looks off in the report.

## `debugLog` (type: `boolean`):

If on, logs every Claude prompt size, every search query, and every Actor call. Helpful when troubleshooting a failed run. Logs are visible in the Apify Console Log tab.

## Actor input object example

```json
{
  "userQuery": "What are the latest developments affecting global oil prices this week?",
  "enableRss": true,
  "enableReddit": false,
  "enableTwitter": false,
  "enableWikipedia": false,
  "claudeModel": "claude-sonnet-4-6",
  "outputLanguage": "English",
  "sourceMode": "auto",
  "manualSources": [],
  "excludeSources": [],
  "tags": [],
  "countries": [],
  "translateToEnglish": true,
  "timeWindow": "last_7d",
  "depth": "medium",
  "maxArticles": 50,
  "bypassPaywalls": true,
  "maxClaudeCost": 5,
  "analysisFeatures": {
    "keywordExtraction": true,
    "impactScoring": true,
    "sentimentAnalysis": true,
    "entityExtraction": true,
    "quoteExtraction": true,
    "themeClustering": true,
    "anomalyDetection": true
  },
  "debugMode": false,
  "debugLog": false
}
```

# Actor output Schema

## `brief` (type: `string`):

Open this view to read the executive summary, top headlines, themes, anomalies, key actors, overall sentiment, and the full markdown report. The articles array carries the underlying cited sources.

# 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 = {
    "userQuery": "What are the latest developments affecting global oil prices this week?",
    "manualSources": [],
    "excludeSources": [],
    "tags": [],
    "countries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("kay_abraham/news-intelligence-agent").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 = {
    "userQuery": "What are the latest developments affecting global oil prices this week?",
    "manualSources": [],
    "excludeSources": [],
    "tags": [],
    "countries": [],
}

# Run the Actor and wait for it to finish
run = client.actor("kay_abraham/news-intelligence-agent").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 '{
  "userQuery": "What are the latest developments affecting global oil prices this week?",
  "manualSources": [],
  "excludeSources": [],
  "tags": [],
  "countries": []
}' |
apify call kay_abraham/news-intelligence-agent --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📰 AI News Brief | Multi-Source Research Agent",
        "description": "Plain English question in → cited intelligence brief out. Pulls Google News, RSS, Reddit, and Twitter. Routes tier-1 publishers to bypass paywalls. Claude analyses each article, flags anomalies, and corroborates across sources. Wikipedia grounds entities.  Built for analysts and policy teams.",
        "version": "0.3",
        "x-build-id": "AVRKjrA3kKBKLNfOi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kay_abraham~news-intelligence-agent/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kay_abraham-news-intelligence-agent",
                "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/kay_abraham~news-intelligence-agent/runs": {
            "post": {
                "operationId": "runs-sync-kay_abraham-news-intelligence-agent",
                "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/kay_abraham~news-intelligence-agent/run-sync": {
            "post": {
                "operationId": "run-sync-kay_abraham-news-intelligence-agent",
                "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",
                "required": [
                    "userQuery",
                    "claudeApiKey",
                    "apifyToken"
                ],
                "properties": {
                    "userQuery": {
                        "title": "Your question",
                        "type": "string",
                        "description": "Ask in plain English. Example: What is the new virus outbreak doing to global supply chains? Focus on shipping, manufacturing, and oil prices."
                    },
                    "claudeApiKey": {
                        "title": "Anthropic Claude API key",
                        "type": "string",
                        "description": "Your Anthropic API key (starts with sk-ant-). Get one at console.anthropic.com. Apify never stores it and never charges you for tokens. You pay Anthropic directly."
                    },
                    "apifyToken": {
                        "title": "Apify API token (required)",
                        "type": "string",
                        "description": "Paste your personal Apify API token here (Apify Console -> Settings -> Integrations -> Personal API tokens). The agent uses it to call its child scraper Actors (rag-web-browser, article-extractor-smart, the dedicated publisher extractors). The platform-issued runtime token is scoped down and these calls fail without your personal token. Apify never reuses this token outside of this run."
                    },
                    "enableRss": {
                        "title": "Use direct RSS feeds from top publishers",
                        "type": "boolean",
                        "description": "When on, the agent pulls articles directly from major publishers' RSS feeds (Reuters, AP, BBC, Bloomberg, FT, Guardian, NYT, WaPo, AlJazeera, CNN, CNBC, Politico) in addition to Google News. RSS feeds publish immediately, removing the 1-3 hour Google News indexing lag. Recommended on for breaking news and live monitoring.",
                        "default": true
                    },
                    "enableReddit": {
                        "title": "Include Reddit discussions",
                        "type": "boolean",
                        "description": "Pull relevant Reddit posts (via trudax/reddit-scraper-lite). Useful for sentiment, community signal, and topics that move on social before mainstream press. Adds ~$0.05 per run.",
                        "default": false
                    },
                    "enableTwitter": {
                        "title": "Include Twitter / X breaking signal",
                        "type": "boolean",
                        "description": "Pull relevant tweets from the last N days (via apidojo/twitter-scraper-lite). Strong for breaking news that hits Twitter 2-6 hours before mainstream press. Adds ~$0.10 per run.",
                        "default": false
                    },
                    "enableWikipedia": {
                        "title": "Enrich analysis with Wikipedia entity context",
                        "type": "boolean",
                        "description": "When on, the agent fetches Wikipedia summaries for the most-mentioned organizations, people, and countries in the article set. Claude uses this context in synthesis to ground its analysis in factual entity data. Adds ~$0.02 per run.",
                        "default": false
                    },
                    "claudeModel": {
                        "title": "Claude model",
                        "enum": [
                            "claude-sonnet-4-6",
                            "claude-haiku-4-5-20251001",
                            "claude-opus-4-7"
                        ],
                        "type": "string",
                        "description": "Sonnet is the default balance of quality and cost. Haiku is fastest and cheapest. Opus is most thorough but slowest and most expensive.",
                        "default": "claude-sonnet-4-6"
                    },
                    "outputLanguage": {
                        "title": "Output language",
                        "enum": [
                            "English",
                            "Arabic",
                            "Chinese (Simplified)",
                            "Chinese (Traditional)",
                            "Spanish",
                            "French",
                            "German",
                            "Russian",
                            "Japanese",
                            "Portuguese",
                            "Italian",
                            "Hindi",
                            "Korean",
                            "Turkish"
                        ],
                        "type": "string",
                        "description": "Language of the final report. Articles are still pulled in their original language and translated for analysis if needed.",
                        "default": "English"
                    },
                    "sourceMode": {
                        "title": "Source selection mode",
                        "enum": [
                            "auto",
                            "manual",
                            "hybrid"
                        ],
                        "type": "string",
                        "description": "Auto: Claude picks a balanced source set for your topic. Manual: only the sources you list. Hybrid: Claude suggestions plus yours.",
                        "default": "auto"
                    },
                    "manualSources": {
                        "title": "Manual source list",
                        "type": "array",
                        "description": "Domains to include. Examples: bbc.com, reuters.com, ft.com, bloomberg.com, aljazeera.com. Only used in manual or hybrid mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeSources": {
                        "title": "Excluded sources",
                        "type": "array",
                        "description": "Domains to skip even if Claude would otherwise suggest them.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "tags": {
                        "title": "Semantic tags (optional)",
                        "type": "array",
                        "description": "Extra keywords or entity names Claude should weigh when filtering. Example: OPEC, semiconductors, NATO. Articles mentioning these get boosted relevance.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Country focus (optional)",
                        "type": "array",
                        "description": "ISO codes of countries to focus on. Example: US, CN, RU, UK, FR, DE, JP, IN, SA, AE, IR. Leave empty for global.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "translateToEnglish": {
                        "title": "Translate non-English articles during analysis",
                        "type": "boolean",
                        "description": "If true, Claude reads non-English articles in their original language and produces analysis in your chosen output language. If false, only articles in your output language are considered.",
                        "default": true
                    },
                    "timeWindow": {
                        "title": "Time window",
                        "enum": [
                            "last_24h",
                            "last_7d",
                            "last_30d",
                            "last_90d",
                            "custom"
                        ],
                        "type": "string",
                        "description": "How recent the articles should be. Pick a preset, or choose 'custom' and set dateFrom and dateTo below.",
                        "default": "last_7d"
                    },
                    "dateFrom": {
                        "title": "Custom date range: from",
                        "type": "string",
                        "description": "Only used if timeWindow is 'custom'. ISO format YYYY-MM-DD. Example: 2026-04-01."
                    },
                    "dateTo": {
                        "title": "Custom date range: to",
                        "type": "string",
                        "description": "Only used if timeWindow is 'custom'. ISO format YYYY-MM-DD. Example: 2026-05-12."
                    },
                    "depth": {
                        "title": "Research depth",
                        "enum": [
                            "shallow",
                            "medium",
                            "deep"
                        ],
                        "type": "string",
                        "description": "Shallow returns about 20 articles, medium about 50, deep about 100. Deeper means higher Claude token cost.",
                        "default": "medium"
                    },
                    "maxArticles": {
                        "title": "Max articles cap",
                        "minimum": 5,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard ceiling on articles to deeply analyze. Overrides depth if smaller.",
                        "default": 50
                    },
                    "bypassPaywalls": {
                        "title": "Bypass paywalls when possible",
                        "type": "boolean",
                        "description": "Uses Googlebot user-agent on the Smart Article Extractor to access sites like Bloomberg and FT. Costs slightly more compute.",
                        "default": true
                    },
                    "customInstructions": {
                        "title": "Custom instructions for Claude (optional)",
                        "type": "string",
                        "description": "Power users only. Extra guidance for Claude on top of your question. Example: Weight Reuters and BBC 2x. Ignore opinion pieces. Highlight any mention of central bank rate changes."
                    },
                    "maxClaudeCost": {
                        "title": "Max Claude spending per run (USD)",
                        "minimum": 0.1,
                        "maximum": 100,
                        "type": "number",
                        "description": "Hard ceiling on Claude token spend. The run stops cleanly if Claude tokens would exceed this. Protects you from runaway prompts.",
                        "default": 5
                    },
                    "analysisFeatures": {
                        "title": "Analysis features",
                        "type": "object",
                        "description": "Toggle which per-article analyses run. Disabling reduces token cost. Default is everything on.",
                        "default": {
                            "keywordExtraction": true,
                            "impactScoring": true,
                            "sentimentAnalysis": true,
                            "entityExtraction": true,
                            "quoteExtraction": true,
                            "themeClustering": true,
                            "anomalyDetection": true
                        }
                    },
                    "webhookUrl": {
                        "title": "Webhook URL (optional)",
                        "type": "string",
                        "description": "If set, the final markdown report is POSTed to this URL. Useful for Slack, email automation, or any other system."
                    },
                    "debugMode": {
                        "title": "Debug mode (extra detail in output)",
                        "type": "boolean",
                        "description": "If on, stores the raw Claude plan, the search queries used, and per-stage timing in the output dataset. Helpful when something looks off in the report.",
                        "default": false
                    },
                    "debugLog": {
                        "title": "Verbose logging",
                        "type": "boolean",
                        "description": "If on, logs every Claude prompt size, every search query, and every Actor call. Helpful when troubleshooting a failed run. Logs are visible in the Apify Console Log tab.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
