# Brave AI Mode Scraper (`codingfrontend/brave-ai-mode-scraper`) Actor

Scrapes Brave Search's AI Summarizer answers (AI Mode). Extracts the AI-synthesized summary text, cited sources, related questions, and accompanying organic results for any query.

- **URL**: https://apify.com/codingfrontend/brave-ai-mode-scraper.md
- **Developed by:** [Coding Frontned](https://apify.com/codingfrontend) (community)
- **Categories:** AI, Developer tools, Other
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.99 / 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.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Brave AI Mode Scraper

Extract AI-generated answers from [Brave AI Mode](https://search.brave.com/?q=...\&summary=1) — Brave's privacy-focused AI search that provides summarised answers with cited sources, without sending your data to third parties.

### Features

- **AI summary** — full text of the AI-generated answer
- **Cited sources** — array of `{title, url}` objects cited in the answer
- **Related questions** — follow-up questions suggested by Brave AI
- **Organic results** — accompanying web results shown alongside the AI answer
- **Metadata** — summary length, sources count, scrape timestamp
- **Geo-targeting** — set `country` and `language` for localised AI responses
- **Proxy support** — works with Apify residential/datacenter proxies

### Input Parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `query` | string | *(required)* | Question or search query for Brave AI Mode |
| `country` | string | `"us"` | Country code for localised results |
| `language` | string | `"en"` | Language code |
| `proxyConfiguration` | object | — | Apify proxy config (recommended: residential) |

#### Example INPUT.json

```json
{
    "query": "What is quantum computing and how does it work?",
    "country": "us",
    "language": "en",
    "proxyConfiguration": { "useApifyProxy": true }
}
```

### Output Fields

| Field | Type | Description |
|-------|------|-------------|
| `query` | string | The query sent to Brave AI Mode |
| `aiSummary` | string | Full text of the AI-generated answer |
| `aiSummaryLength` | integer | Character count of the AI summary |
| `hasSummary` | boolean | Whether a Brave AI answer was returned |
| `sources` | array | Cited sources — array of `{title, url}` objects |
| `sourcesCount` | integer | Number of cited sources |
| `relatedQuestions` | array | Follow-up / related questions from Brave AI |
| `organicResults` | array | Top organic web results shown alongside the AI answer |
| `matchedSelector` | string | CSS selector that matched the AI summary container (debug field) |
| `searchUrl` | string | Full Brave search URL used |
| `country` | string | Country code used |
| `language` | string | Language code used |
| `error` | string | Error message (null unless the AI answer could not be retrieved) |
| `scrapedAt` | string | ISO 8601 scrape timestamp |

#### Example Output

```json
{
    "query": "What is quantum computing and how does it work?",
    "aiSummary": "Quantum computing is a type of computation that uses quantum-mechanical phenomena such as superposition and entanglement to process information...",
    "aiSummaryLength": 2847,
    "hasSummary": true,
    "sources": [
        { "title": "IBM — What is quantum computing?", "url": "https://www.ibm.com/topics/quantum-computing" },
        { "title": "Wikipedia — Quantum computing", "url": "https://en.wikipedia.org/wiki/Quantum_computing" }
    ],
    "sourcesCount": 12,
    "relatedQuestions": [
        "How is quantum computing different from classical computing?",
        "What are the practical applications of quantum computers?"
    ],
    "organicResults": [
        { "title": "Quantum Computing Explained", "url": "https://quantum.country/", "snippet": "..." }
    ],
    "matchedSelector": "#summary-container",
    "searchUrl": "https://search.brave.com/search?q=What+is+quantum+computing&summary=1&country=us&lang=en",
    "country": "us",
    "language": "en",
    "error": null,
    "scrapedAt": "2025-05-01T12:00:00.000Z"
}
```

### Notes

- Each run processes a **single query** — one dataset item per run
- `hasSummary: false` indicates Brave did not return an AI answer for the query (may occur for very recent events or unsupported query types)
- Brave AI Mode requires the `summary=1` URL parameter — this is handled automatically by the scraper
- The AI summary content depends on Brave's server-side AI response and may vary between runs
- There is **no pagination** for AI Mode — each query produces one result item
- Use a **residential proxy** for consistent access to the AI answer endpoint

### Why Use This Scraper?

- **Privacy-first AI answers** — Brave's AI answers are generated without tracking or profiling users
- **Independent AI model** — Brave uses its own AI stack (not OpenAI) for local AI Mode answers
- **Source transparency** — Brave AI explicitly cites sources in its answers
- **Research automation** — test hundreds of queries for AI answer presence and content

### Use Cases

- **Privacy AI Research** — study AI answer quality from a non-Google, privacy-first perspective
- **SEO Source Attribution** — track which pages Brave AI cites as authoritative sources
- **AI Answer Benchmarking** — compare Brave AI answers vs Google AI Overviews for the same queries
- **Content Strategy** — ensure your content is cited in Brave's AI answers for your topics
- **Brand Monitoring** — see how Brave's AI describes your brand or products

### Custom Solutions

Need a custom scraper or dedicated server setup? We offer:

- **On-demand scraper development** for any website
- **Individual server setups** with your own infrastructure
- **Custom modifications** to existing scrapers
- **Priority support** and maintenance

📧 Email: lakshmanan.w3dev@gmail.com\
📱 WhatsApp: +91 6382775774

# Actor input Schema

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

A single search query to get the Brave AI Summarizer response for.

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

Optional list of queries to process in batch (overrides 'query' if provided).

## `maxItems` (type: `integer`):

Maximum number of queries to process (when using the 'queries' list).

## `country` (type: `string`):

Brave country code for localized results (e.g. 'us', 'gb', 'in').

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

Brave language code (e.g. 'en', 'de', 'fr').

## `waitForSummary` (type: `boolean`):

Whether to wait extra time for the AI summary to load dynamically.

## `summaryTimeoutMs` (type: `integer`):

Maximum milliseconds to wait for the AI summary block to appear.

## `proxyConfiguration` (type: `object`):

Proxy settings. Residential proxies strongly recommended for reliable AI summary access.

## Actor input object example

```json
{
  "query": "What is machine learning",
  "queries": [
    "What is AI",
    "How does machine learning work"
  ],
  "maxItems": 10,
  "country": "us",
  "language": "en",
  "waitForSummary": true,
  "summaryTimeoutMs": 15000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "query": "What is artificial intelligence",
    "maxItems": 10,
    "country": "us",
    "language": "en",
    "summaryTimeoutMs": 15000,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("codingfrontend/brave-ai-mode-scraper").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 = {
    "query": "What is artificial intelligence",
    "maxItems": 10,
    "country": "us",
    "language": "en",
    "summaryTimeoutMs": 15000,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("codingfrontend/brave-ai-mode-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "What is artificial intelligence",
  "maxItems": 10,
  "country": "us",
  "language": "en",
  "summaryTimeoutMs": 15000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call codingfrontend/brave-ai-mode-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,codingfrontend/brave-ai-mode-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hjWFRtbLRLSotOPLr/builds/dXUpCzX6JvmAHDm8c/openapi.json