# AI Deep Research — Multi-Source Research API for Agents (`logiover/ai-deep-research`) Actor
Keyless deep-research API for AI agents. Give it a topic, get ranked web sources + recent news + the full readable content of each source as Markdown, with citations. Clean, cited grounding / RAG material — no API key, no LLM synthesis.
- **URL**: https://apify.com/logiover/ai-deep-research.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Agents, AI, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $9.50 / 1,000 results
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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
## AI Deep Research — Multi-Source Research API for AI Agents, RAG & Grounding (Keyless)
     
**Give it a topic, get everything a deep-research agent needs to reason and cite.** AI Deep Research is a fast, **keyless deep-research API** built for **AI agents, RAG pipelines and grounding**. Send one topic or a batch of fifty and, for each, receive a clean, structured, **cited research bundle**: the top-ranked **web sources**, the **full readable content of every source as Markdown**, and **recent news** — all in one call. No API key, no browser, no rate-limit headaches, no per-token synthesis fee.
Crucially, this Actor **does not synthesize**. There is no LLM inside it and no opinion baked in — it returns clean, cited **source material** so *your* agent's own model can read, reason and write the answer. Think of it as the **retrieval-and-reading layer** of a deep-research stack: it does the searching, fetching, deduping and Markdown conversion; your LLM does the thinking. Large language models have a knowledge cutoff and hallucinate about anything recent or niche — this Actor fixes that by handing your agent **fresh, real sources with full text and citations** instead of guesses.
> ### 🏆 Why this deep-research API?
> **3 signals per topic** (web search + full-page Markdown + recent news) · **up to 20 sources** each · **batch up to 50 topics** per run · **~6,000 chars of clean Markdown** per source · citations out of the box · **resilient dual engine** (DuckDuckGo → Bing fallback) · **keyless** with Apify proxy · **MCP / pay-per-event** so agents can call it autonomously. The unofficial **Tavily / Exa / Perplexity API alternative** for grounded retrieval — without the API key or the synthesis lock-in.
---
### ✨ What this Actor does / Key features
- 🔑 **Keyless & cheap** — no Tavily, Exa, Perplexity, Brave or SerpAPI key required. Runs on plain HTTP through Apify's proxy.
- 🧩 **Multi-source by design** — every topic combines a **web search** + the **full page content** of each result + **recent news**, the three ingredients a research agent needs, in one record.
- 📖 **Deep, not shallow** — turn on **Include source content** (on by default) and each source carries the page's main text as clean **Markdown** (capped ~6,000 chars). Your LLM reads real sources, not one-line snippets.
- 🔖 **Cited out of the box** — every bundle ships a `citations` list (`{n, title, url}`) so the agent can footnote its answer.
- 🛡️ **Resilient dual engine** — DuckDuckGo HTML is primary; if it returns nothing, **Bing takes over automatically**, so you get sources, not empty responses. The `engine` field records which one served.
- 📰 **Fresh news** — recent items from **Google News RSS** (last 30 days): title, URL, publish date, source.
- 🤖 **Agent-native (MCP)** — **pay-per-event** pricing means an AI agent can research a topic, pay per bundle, and reason over the output with no account setup.
- 🌍 **Region / language control** — `us-en`, `uk-en`, `de-de`, `fr-fr`, `es-es` and more.
- 📚 **Batch** — fire up to 50 topics in one run with configurable concurrency.
- 💾 **Export-ready** — JSON, CSV, Excel and a full REST API. One row per topic.
### 🚀 Quick start (3 steps)
1. **Configure** — type one or more topics into **Research topics** (or a single topic into **Single topic**). Optionally set **Max sources per topic** and a **Region / language**.
2. **Run** — click **Start**. The Actor searches the live web, fetches and converts each source to Markdown, and attaches recent news.
3. **Get your data** — open the **Output** tab: one cited research bundle per topic. Export to **JSON, CSV or Excel**, read it live via the Apify API, or call the Actor as an **MCP tool** from your agent.
### 📥 Input
Provide at least one topic — either in the **Research topics** list or the **Single topic** field. Everything else is optional.
#### Example — batch research for a report agent
```json
{
"topics": [
"model context protocol adoption",
"vector database market 2026",
"AI agent orchestration frameworks"
],
"maxSources": 8,
"includeContent": true,
"includeNews": true,
"maxNews": 8,
"region": "us-en",
"concurrency": 2
}
````
#### Example — single deep dive with maximum source content (RAG grounding)
```json
{
"topic": "post-quantum cryptography standards NIST",
"maxSources": 12,
"includeContent": true,
"includeNews": false,
"region": "us-en"
}
```
#### Example — fast news-and-links scan (no full page fetch)
```json
{
"topics": ["OpenAI funding round", "Anthropic enterprise deals"],
"maxSources": 6,
"includeContent": false,
"includeNews": true,
"maxNews": 15,
"region": "us-en",
"concurrency": 4
}
```
| Field | Type | Description |
|-------|------|-------------|
| `topics` | array | One or more topics / questions. Each produces one cited research bundle. Batch up to 50. |
| `topic` | string | A single topic / question. Use this **or** the `topics` list above. |
| `maxSources` | integer | Top-ranked web sources to gather per topic (1–20). Default `6`. |
| `includeContent` | boolean | Fetch each source page and attach its main content as clean Markdown (~6,000 chars). This is what makes it "deep". Default `true`. |
| `includeNews` | boolean | Attach recent news from Google News RSS (last 30 days). Default `true`. |
| `maxNews` | integer | Recent news items to attach per topic (0–30). Set `0` to skip news. Default `8`. |
| `region` | string | Search region / language code, e.g. `us-en`, `uk-en`, `de-de`, `fr-fr`. Default `us-en`. |
| `concurrency` | integer | Topics researched in parallel (1–8). Kept low by default because each topic runs many fetches. Default `2`. |
| `useApifyProxy` | boolean | Route requests through Apify datacenter proxy to avoid per-IP rate limits. Default `true`. |
| `proxyGroups` | array | Override proxy group, e.g. `["RESIDENTIAL"]`. Leave empty for datacenter (AUTO). |
> **Tip:** Keep `includeContent` on for RAG and report-writing (your LLM reads full sources); turn it off for a lightweight links-and-news scan that runs faster and cheaper. Each source adds one page fetch, so a lower `concurrency` keeps runs stable when `maxSources` is high.
### 📤 Output
One row per topic — a self-contained, cited research bundle. Here is a trimmed sample record (long arrays and content truncated with `…`):
```json
{
"topic": "model context protocol adoption",
"sources": [
{
"rank": 1,
"title": "Model Context Protocol — An open standard for AI tools",
"url": "https://modelcontextprotocol.io",
"snippet": "MCP standardizes how applications provide context to LLMs…",
"source": "modelcontextprotocol.io",
"content": "# Model Context Protocol\n\nMCP is an open protocol that standardizes how applications provide context to large language models…",
"contentWordCount": 812
},
{ "rank": 2, "title": "…", "url": "https://…", "snippet": "…", "source": "…", "content": "…", "contentWordCount": 640 }
],
"news": [
{
"title": "Anthropic's MCP gains traction across IDEs",
"url": "https://news.example.com/mcp",
"publishedAt": "Wed, 02 Jul 2026 09:00:00 GMT",
"source": "Example News"
}
],
"citations": [
{ "n": 1, "title": "Model Context Protocol — An open standard for AI tools", "url": "https://modelcontextprotocol.io" },
{ "n": 2, "title": "…", "url": "https://…" }
],
"sourceCount": 6,
"newsCount": 8,
"engine": "duckduckgo",
"generatedAt": "2026-07-04T10:00:00.000Z"
}
```
📋 Full field reference (click to expand)
| Field | Description |
|-------|-------------|
| `topic` | The topic / question that was researched |
| `sources` | Array of ranked sources, each `{ rank, title, url, snippet, source, content, contentWordCount }` |
| `sources[].rank` | Result rank within the topic (1 = top) |
| `sources[].title` | Source page title |
| `sources[].url` | Source page URL |
| `sources[].snippet` | Search-result snippet for the source |
| `sources[].source` | Source domain (e.g. `modelcontextprotocol.io`) |
| `sources[].content` | Main page text as clean Markdown (capped ~6,000 chars). Present when `includeContent` is on |
| `sources[].contentWordCount` | Word count of the extracted Markdown content |
| `news` | Array of recent news items, each `{ title, url, publishedAt, source }` (last 30 days) |
| `citations` | Citation list for the agent: `{ n, title, url }` |
| `sourceCount` | Number of sources gathered for this topic |
| `newsCount` | Number of news items attached |
| `engine` | Which engine served the sources — `duckduckgo` or `bing` |
| `error` | Set when a topic could not be researched; otherwise `null` |
| `generatedAt` | ISO 8601 timestamp the bundle was produced |
### 💡 Use cases
- **Deep research agents** — the retrieval + reading layer for an agent that writes long, cited reports. It gathers and reads sources; your LLM synthesizes.
- **RAG & grounding** — drop full-text, cited sources straight into a prompt or vector store instead of stale training data.
- **Research automation** — batch dozens of questions and collect ranked, read sources plus fresh news in one run.
- **Market & competitive intel** — one topic → sources + recent news, ready to summarize.
- **Answer engines & chatbots** — power a bot that answers with links and citations, not hallucinations.
- **Fact-checking & briefings** — pull the current top sources and last-30-days news on any subject on demand.
### 👥 Who uses it
AI engineers & agent builders · RAG / LLMOps teams · researchers & analysts automating literature and market scans · product teams building answer engines and research assistants · founders and consultants who need fast, cited briefings · anyone replacing a paid search/grounding API with a keyless, pay-as-you-go alternative.
### 🤖 Use it as an MCP tool
This Actor uses Apify's **pay-per-event** model, so AI agents can discover and call it autonomously through the **Apify MCP server** — one charge per topic bundle. Wire it into **Claude, Cursor, or any MCP client** and let the agent research the live web, read the sources, and cite them on demand — no account setup, no key handling.
### 💰 Pricing
This Actor runs on a simple **pay-per-result** (pay-per-event) model — **one charge per topic bundle returned**. Topics that yield no sources still push a row but are **not charged**. There is no monthly fee and no idle cost. Try it on the **free tier** first, then scale up; see the **Pricing** tab on this page for the current rate.
### ❓ Frequently Asked Questions
#### Is this a Tavily / Exa / Perplexity API alternative?
Yes — it covers the **deep-research / grounding** job those tools are used for (multi-source retrieval, full-page reading and citations) **without their API keys**. The difference: it returns raw, cited source material and leaves synthesis to your own LLM, so you keep full control and pay no per-token synthesis fee.
#### Does it use an LLM or write the answer for me?
No. There is **no LLM inside**. It searches, reads and cites sources; your research agent's model does the reasoning and writing. That keeps it keyless, deterministic and cheap.
#### Can I use it without an API key or login?
Yes. It's fully **keyless** — no Tavily/Exa/SerpAPI key, no third-party signup, only an Apify account. It works out of the box with Apify's datacenter proxy.
#### Where do the sources come from?
A live web search — **DuckDuckGo HTML** first, with an automatic **Bing fallback** for resilience — plus recent news from **Google News RSS** (last 30 days). The `engine` field tells you which search served each bundle.
#### Can it return the full page content, not just snippets?
Yes — that's the point. **Include source content** (on by default) attaches each source page's main content as clean **Markdown** (capped ~6,000 chars), ideal for RAG and deep reading.
#### How do I export the research to CSV or JSON?
Run the Actor, then export the dataset as **JSON, CSV, Excel or JSONL** from the Apify console or via the REST API. One topic = one row.
#### How much data can I get per run?
Up to **50 topics per run**, each with up to **20 sources** and **30 news items**. With `includeContent` on, every source carries ~6,000 chars of Markdown — so a single run can return a large, fully-cited research corpus.
#### Can I research in other languages/regions?
Yes. Set the **Region / language** field, e.g. `uk-en`, `de-de`, `fr-fr`, `es-es`.
#### Is it legal to use?
The Actor retrieves only publicly available web pages and news. You are responsible for using the returned content in compliance with each source's terms and applicable law (including copyright and data-protection rules).
#### Why is the default concurrency low?
Each topic runs many fetches (a search, one fetch per source, and news), so a lower concurrency keeps runs stable and friendly to sources. Raise it if you have many light topics or turn `includeContent` off.
### 🔗 More AI & research-intel Actors by logiover
Building an AI research or grounding stack? Pair AI Deep Research with the rest of the suite:
| Actor | What it does |
|---|---|
| [AI Web Search](https://apify.com/logiover/ai-web-search) | Keyless live web search results for agents |
| [AI Web Extract](https://apify.com/logiover/ai-web-extract) | Turn any URL into clean, LLM-ready content |
| [AI Citation Source Finder](https://apify.com/logiover/ai-citation-source-finder) | Find citable sources for any claim |
| [Company Deep Research Scraper](https://apify.com/logiover/company-deep-research-scraper) | Multi-source company research dossiers |
| [News Intelligence Scraper](https://apify.com/logiover/news-intelligence-scraper) | Aggregated, structured news feeds |
| [Google News Scraper](https://apify.com/logiover/google-news-scraper) | Scrape Google News results at scale |
| [SERP Keyword Research](https://apify.com/logiover/serp-keyword-research) | Keyword and SERP data for research |
| [arXiv Paper Scraper](https://apify.com/logiover/arxiv-paper-scraper) | Fetch academic papers and metadata from arXiv |
| [Semantic Scholar Research Scraper](https://apify.com/logiover/semantic-scholar-research-scraper) | Academic papers, citations and authors |
| [Hugging Face Hub Intelligence Scraper](https://apify.com/logiover/huggingface-hub-intelligence-scraper) | Models, datasets and Spaces intelligence |
| [GitHub Repository Scraper](https://apify.com/logiover/github-repository-scraper) | Repo metadata, stars and activity |
| [npm Package Intelligence Scraper](https://apify.com/logiover/npm-package-intelligence-scraper) | Package stats, deps and release data |
| [CVE Security Advisory Monitor](https://apify.com/logiover/cve-security-advisory-monitor) | Track new CVEs and advisories |
| [B2B AI Visibility Tracker](https://apify.com/logiover/b2b-ai-visibility-tracker) | Measure brand visibility in AI answers |
👉 Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** — 180+ actors across real estate, jobs, crypto, social media & B2B data.
### ⏰ Scheduling & integration
Schedule this Actor on Apify to refresh a research corpus daily or weekly and keep your grounding data current. Export results to JSON, CSV or Excel, sync to **Google Sheets**, or push straight into your **vector store, database, BI tools and webhooks** through the Apify API. Connect it to **Make, n8n or Zapier** to build automated research pipelines — or call it as an **MCP tool** directly from an AI agent.
### ⭐ Support & feedback
Need an extra field or a different engine? Open an issue on the **Issues** tab — response is usually fast. If this Actor saves you time, a **★★★★★ review** on the Store page genuinely helps and is hugely appreciated. 🙏
### ⚖️ Legal
This Actor retrieves only publicly available web pages and news items and is intended for legitimate research, grounding and analytics use. It does not synthesize or alter source content. You are responsible for using the returned material in compliance with each source's terms of service, copyright and any applicable data-protection laws.
***
### 📝 Changelog
#### 2026-07-06
- ✨ README overhaul: rising-star formatting, badge row, named example scenarios, full field reference, expanded keyword-gap FAQ and AI-research cross-promo grid.
#### 2026-07-04
- Initial release: keyless multi-source deep-research API for AI agents and RAG.
- Per topic: runs a web search (DuckDuckGo HTML primary, Bing automatic fallback) and gathers the top `maxSources` ranked sources — rank, title, URL, snippet, source domain.
- Optional `includeContent` (on by default) — fetches each source page and attaches its main content as clean Markdown (capped ~6000 chars) so the agent reads full sources, not just snippets. Fetched in parallel per topic.
- Optional `includeNews` (on by default) — attaches recent news from Google News RSS (last 30 days): title, URL, publish date, source.
- Assembles one cited record per topic with a citation list (`{n, title, url}`), `sourceCount` and `newsCount`.
- Does NOT synthesize (no LLM) — returns clean, structured, cited source material the agent's own LLM reasons over.
- Region/language control; batch topics with configurable (low) concurrency since each topic runs many fetches.
- Keyless; Apify datacenter proxy by default (RESIDENTIAL opt-in).
- Pay-per-event pricing: one charge per topic bundle. Topics that yield no sources still push a row (no charge). Agent-first, works as an MCP tool.
# Actor input Schema
## `topics` (type: `array`):
One or more topics / questions to research, e.g. `model context protocol adoption`. Each produces one cited research bundle. Batch up to 50.
## `topic` (type: `string`):
A single topic / question. Use this or the topics list above.
## `maxSources` (type: `integer`):
How many top-ranked web sources to gather per topic (1–20).
## `includeContent` (type: `boolean`):
Fetch each source page and attach its main content as clean Markdown (capped ~6000 chars). This is what makes it 'deep' — the agent reads full sources, not just snippets. Adds one fetch per source.
## `includeNews` (type: `boolean`):
Attach recent news items about the topic from Google News RSS (last 30 days) — title, URL, publish date, source.
## `maxNews` (type: `integer`):
How many recent news items to attach per topic (0–30). Set 0 to skip news entirely.
## `region` (type: `string`):
Search region and language code for web sources, e.g. `us-en`, `uk-en`, `de-de`, `fr-fr`.
## `concurrency` (type: `integer`):
How many topics to research in parallel. Kept low by default because each topic runs many fetches (search + one per source + news).
## `useApifyProxy` (type: `boolean`):
Route requests through Apify datacenter proxy. Recommended to avoid per-IP rate limits.
## `proxyGroups` (type: `array`):
Override proxy group, e.g. `RESIDENTIAL`. Leave empty for datacenter (AUTO).
## Actor input object example
```json
{
"topics": [
"model context protocol adoption"
],
"topic": "vector database market 2026",
"maxSources": 6,
"includeContent": true,
"includeNews": true,
"maxNews": 8,
"region": "us-en",
"concurrency": 2,
"useApifyProxy": true,
"proxyGroups": []
}
```
# Actor output Schema
## `results` (type: `string`):
Full dataset of research bundles. One row = one topic.
# 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 = {
"topics": [
"model context protocol adoption"
],
"maxSources": 6,
"includeContent": true,
"includeNews": true,
"maxNews": 8,
"region": "us-en",
"concurrency": 2,
"useApifyProxy": true
};
// Run the Actor and wait for it to finish
const run = await client.actor("logiover/ai-deep-research").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 = {
"topics": ["model context protocol adoption"],
"maxSources": 6,
"includeContent": True,
"includeNews": True,
"maxNews": 8,
"region": "us-en",
"concurrency": 2,
"useApifyProxy": True,
}
# Run the Actor and wait for it to finish
run = client.actor("logiover/ai-deep-research").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 '{
"topics": [
"model context protocol adoption"
],
"maxSources": 6,
"includeContent": true,
"includeNews": true,
"maxNews": 8,
"region": "us-en",
"concurrency": 2,
"useApifyProxy": true
}' |
apify call logiover/ai-deep-research --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=logiover/ai-deep-research",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "AI Deep Research — Multi-Source Research API for Agents",
"description": "Keyless deep-research API for AI agents. Give it a topic, get ranked web sources + recent news + the full readable content of each source as Markdown, with citations. Clean, cited grounding / RAG material — no API key, no LLM synthesis.",
"version": "1.0",
"x-build-id": "eP9zEZBTOVP9ViNbe"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/logiover~ai-deep-research/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-logiover-ai-deep-research",
"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/logiover~ai-deep-research/runs": {
"post": {
"operationId": "runs-sync-logiover-ai-deep-research",
"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/logiover~ai-deep-research/run-sync": {
"post": {
"operationId": "run-sync-logiover-ai-deep-research",
"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": {
"topics": {
"title": "Research topics",
"type": "array",
"description": "One or more topics / questions to research, e.g. `model context protocol adoption`. Each produces one cited research bundle. Batch up to 50.",
"items": {
"type": "string"
},
"default": []
},
"topic": {
"title": "Single topic",
"type": "string",
"description": "A single topic / question. Use this or the topics list above."
},
"maxSources": {
"title": "Max sources per topic",
"minimum": 1,
"maximum": 20,
"type": "integer",
"description": "How many top-ranked web sources to gather per topic (1–20).",
"default": 6
},
"includeContent": {
"title": "Include source content (Markdown)",
"type": "boolean",
"description": "Fetch each source page and attach its main content as clean Markdown (capped ~6000 chars). This is what makes it 'deep' — the agent reads full sources, not just snippets. Adds one fetch per source.",
"default": true
},
"includeNews": {
"title": "Include recent news",
"type": "boolean",
"description": "Attach recent news items about the topic from Google News RSS (last 30 days) — title, URL, publish date, source.",
"default": true
},
"maxNews": {
"title": "Max news items per topic",
"minimum": 0,
"maximum": 30,
"type": "integer",
"description": "How many recent news items to attach per topic (0–30). Set 0 to skip news entirely.",
"default": 8
},
"region": {
"title": "Region / language",
"type": "string",
"description": "Search region and language code for web sources, e.g. `us-en`, `uk-en`, `de-de`, `fr-fr`.",
"default": "us-en"
},
"concurrency": {
"title": "Concurrency (topics in parallel)",
"minimum": 1,
"maximum": 8,
"type": "integer",
"description": "How many topics to research in parallel. Kept low by default because each topic runs many fetches (search + one per source + news).",
"default": 2
},
"useApifyProxy": {
"title": "Use Apify datacenter proxy",
"type": "boolean",
"description": "Route requests through Apify datacenter proxy. Recommended to avoid per-IP rate limits.",
"default": true
},
"proxyGroups": {
"title": "Proxy groups (advanced)",
"type": "array",
"description": "Override proxy group, e.g. `RESIDENTIAL`. Leave empty for datacenter (AUTO).",
"items": {
"type": "string"
},
"default": []
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```