# Deep Research Agent — AI Web Research to Structured JSON (`rockboat/deep-research-agent`) Actor

Autonomous AI research agent that searches and analyzes 10-30 web sources, then synthesizes findings into a structured JSON report. Supports English and Korean output. Ideal for content creation, competitive intelligence, and market research.

- **URL**: https://apify.com/rockboat/deep-research-agent.md
- **Developed by:** [patrick](https://apify.com/rockboat) (community)
- **Categories:** AI, Agents
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 research report delivereds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Deep Research Agent — Automated Web Research & AI Synthesis to Structured JSON

The **Deep Research Agent** is an AI research automation tool that searches the web, fetches and analyzes up to 30 sources, and synthesizes findings into a structured JSON report — fully automated, no coding required.

Whether you need competitive intelligence, SEO keyword research, content briefs, or a pay-per-use alternative to OpenAI Deep Research and Perplexity, this Actor delivers structured, actionable intelligence on any topic in minutes.

---

### What This AI Research Agent Does

1. **Multi-query web search** — Generates multiple search query variants and queries Brave Search to find the most relevant, up-to-date sources
2. **Automated content extraction** — Fetches and cleans full-text content from each source, removing ads, navigation, and noise
3. **AI synthesis** — Uses DeepSeek to read all sources simultaneously and synthesize key findings into a structured JSON report
4. **GEO optimization** — Generates a 130–170 word citation-ready answer optimized for AI search engines (ChatGPT, Perplexity, Claude, Google SGE)

---

### Output: Structured Research Report (JSON)

Every run produces a clean, machine-readable JSON object ready for downstream automation, content pipelines, or API integrations:

```json
{
  "topic": "best AI coding assistants 2026",
  "keyword": "AI coding assistant",
  "type": "comparison",
  "summary": "A 2–3 sentence executive summary of the research findings...",
  "competitors": [
    { "url": "https://...", "key_points": ["point 1", "point 2"] }
  ],
  "stats": [
    { "fact": "GitHub Copilot has 1.8M paid subscribers", "source": "https://..." }
  ],
  "angles": [
    "Most tools lack offline mode — an underserved use case",
    "Enterprise security compliance is the top buyer concern"
  ],
  "keywords": ["AI coding assistant", "GitHub Copilot alternative", "code completion AI"],
  "outline": [
    "H2: What Is an AI Coding Assistant?",
    "H2: Top 7 AI Coding Assistants Compared",
    "H2: How to Choose the Right Tool for Your Team"
  ],
  "geo_angle": {
    "core_answer": "130–170 word self-contained answer optimized for AI search citation...",
    "key_stats": ["GitHub Copilot: 1.8M subscribers (2025)", "..."],
    "related_questions": ["What is the best free AI coding assistant?", "..."],
    "entity_signals": ["GitHub Copilot", "Cursor", "Tabnine", "Codeium"]
  },
  "sources_count": 15,
  "sources": [{ "url": "https://...", "title": "Article title" }],
  "research_date": "2026-04-14"
}
````

***

### Use Cases

#### Content Creation & SEO

Research any topic before writing a blog post, article, or video script. Get a full outline, key statistics, unique angles, and competitor content analysis in one run.

#### Competitive Intelligence Automation

Track what's being said about competitors, analyze their content strategy, and identify gaps — automatically, at scale.

#### Market Research Automation

Synthesize information from 15–30 sources on any market, product, or trend without spending hours manually browsing.

#### AI Search Optimization (GEO)

The `geo_angle` field outputs a structured, citation-ready answer designed to be referenced by ChatGPT, Perplexity, Claude, and Google SGE. Ideal for brands optimizing for AI-generated search results.

#### Developer & API Integration

The JSON output integrates directly into n8n, Zapier, Make, or any custom pipeline. Use it as a research layer in your AI applications.

#### OpenAI Deep Research Alternative

Unlike OpenAI Deep Research (requires ChatGPT Plus subscription) or Perplexity (subscription-based), this Actor uses pay-per-event pricing — you only pay for what you actually run.

***

### Input Parameters

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `query` | string | ✅ Yes | Research question, topic, or keyword to investigate |
| `depth` | string | No | `shallow` (5 sources ~$0.80), `medium` (15 sources ~$1.30), `deep` (30 sources ~$2.05). Default: `medium` |
| `language` | string | No | `en` (English) or `ko` (Korean). Default: `en` |
| `focusAreas` | array | No | Specific subtopics or angles to emphasize (e.g., `["pricing", "enterprise features"]`) |
| `includeGeoAngle` | boolean | No | Include AI search optimization section. Default: `true` |

***

### Pricing

This Actor uses **pay-per-event** (PPE) pricing — no monthly subscription, no wasted spend:

| Event | Price | When |
|-------|-------|------|
| Actor start | $0.05 | Once per run, on initialization |
| Source fetched | $0.05 | Per web source analyzed |
| Report delivered | $0.50 | Once, when final report is generated |

**Estimated total cost per run:**

| Depth | Sources | Estimated Cost |
|-------|---------|----------------|
| Shallow | 5 | ~$0.80 |
| Medium | 15 | ~$1.30 |
| Deep | 30 | ~$2.05 |

Compare to OpenAI Deep Research (requires $20/month ChatGPT Plus) or Perplexity Pro ($20/month). With PPE pricing, you only pay when you run — ideal for occasional or high-volume automated research.

***

### Frequently Asked Questions

**What makes this different from OpenAI Deep Research or Perplexity?**
This Actor uses pay-per-event pricing (no subscription), delivers structured JSON output for programmatic use, and runs as a fully automated API — not a chat interface. It's designed for developers and automation workflows, not manual browsing.

**Can I use this for automated competitive intelligence?**
Yes. Run it on any competitor's product name, feature set, or market category to get a synthesized report with key points, statistics, and angles extracted from across the web.

**Does it support languages other than English?**
Yes. Set `language: "ko"` to receive the full report in Korean. Additional language support planned.

**How many sources does it analyze?**

- Shallow: up to 5 sources
- Medium: up to 15 sources (recommended)
- Deep: up to 30 sources

**What is the `geo_angle` field?**
It's a structured section containing a 130–170 word answer written specifically to be cited by AI search engines (ChatGPT with web search, Perplexity, Claude, Google SGE). This helps brands and content marketers appear in AI-generated search answers.

**Can I integrate this into my automation pipeline?**
Yes. The JSON output works natively with n8n, Zapier, Make, and any REST API consumer. Use the Apify API to trigger runs and retrieve results programmatically.

**What data does the report contain?**
Topic, primary keyword, content type classification, executive summary, source analysis with key points, notable statistics with sources, unique content angles, SEO keywords, article outline, AI search optimization section, and full list of analyzed sources.

***

### Technical Details

- **Search**: Brave Search API (privacy-focused, no Google bias)
- **AI Model**: DeepSeek via Ollama Cloud
- **Runtime**: Python 3.12 on Apify platform
- **Typical run time**: 1–4 minutes depending on depth
- **Output**: Apify dataset (JSON) + key-value store

***

### Related Actors

Looking for more research and intelligence tools? Check out other Actors by the same developer.

***

*Built for the AI search era. Research smarter, publish faster.*

# Actor input Schema

## `query` (type: `string`):

The topic, question, or keyword to research

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

shallow = 5 sources (~$0.50), medium = 15 sources (~$1.50), deep = 30 sources (~$3.00)

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

Language for the research report

## `focusAreas` (type: `array`):

Specific aspects to focus on. Leave empty for general research.

## `includeGeoAngle` (type: `boolean`):

Include a citation-ready answer block optimized for AI search engines (ChatGPT, Perplexity, Claude)

## Actor input object example

```json
{
  "query": "Best AI agent frameworks comparison 2026",
  "depth": "medium",
  "language": "en",
  "focusAreas": [
    "market size",
    "key players",
    "pricing comparison"
  ],
  "includeGeoAngle": true
}
```

# Actor output Schema

## `report` (type: `string`):

Structured JSON research report. Access via dataset API.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("rockboat/deep-research-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("rockboat/deep-research-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 '{}' |
apify call rockboat/deep-research-agent --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Deep Research Agent — AI Web Research to Structured JSON",
        "description": "Autonomous AI research agent that searches and analyzes 10-30 web sources, then synthesizes findings into a structured JSON report. Supports English and Korean output. Ideal for content creation, competitive intelligence, and market research.",
        "version": "1.0",
        "x-build-id": "HfSnq2sFnDSIddCAQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rockboat~deep-research-agent/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rockboat-deep-research-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/rockboat~deep-research-agent/runs": {
            "post": {
                "operationId": "runs-sync-rockboat-deep-research-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/rockboat~deep-research-agent/run-sync": {
            "post": {
                "operationId": "run-sync-rockboat-deep-research-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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Research Query",
                        "minLength": 5,
                        "maxLength": 500,
                        "type": "string",
                        "description": "The topic, question, or keyword to research"
                    },
                    "depth": {
                        "title": "Research Depth",
                        "enum": [
                            "shallow",
                            "medium",
                            "deep"
                        ],
                        "type": "string",
                        "description": "shallow = 5 sources (~$0.50), medium = 15 sources (~$1.50), deep = 30 sources (~$3.00)",
                        "default": "medium"
                    },
                    "language": {
                        "title": "Output Language",
                        "enum": [
                            "en",
                            "ko"
                        ],
                        "type": "string",
                        "description": "Language for the research report",
                        "default": "en"
                    },
                    "focusAreas": {
                        "title": "Focus Areas (optional)",
                        "type": "array",
                        "description": "Specific aspects to focus on. Leave empty for general research.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeGeoAngle": {
                        "title": "Include GEO (AI Search) Angle",
                        "type": "boolean",
                        "description": "Include a citation-ready answer block optimized for AI search engines (ChatGPT, Perplexity, Claude)",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
