# Brave News Search Scraper (`automation-lab/brave-news-search-scraper`) Actor

Search Brave News by keyword and export ranked headlines, publishers, publication times, snippets, destination URLs, and thumbnails for monitoring, research, or RAG.

- **URL**: https://apify.com/automation-lab/brave-news-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Brave News Search Scraper

Search Brave's independent news index and export clean, ranked article records without opening every publisher page.

Use **Brave News Search Scraper** to turn keyword searches into structured headlines, publishers, publication times, destination URLs, snippets, thumbnails, and ranking context. Run one query for quick research or schedule a list of brand, market, policy, and competitor queries for continuous monitoring.

- 🔎 Search up to 20 keyword queries in one run
- 📰 Export up to 200 ranked articles per query
- 🌍 Localize results by country and language
- 🕒 Filter to the past day, week, month, or year
- 🔗 Keep direct publisher URLs and the exact Brave source page
- 🤖 Send results to AI agents, RAG pipelines, Sheets, Slack, or a warehouse

The Actor uses the public Brave News result surface. It does **not** require a Brave API key, a Brave account, or publisher credentials.

### What does Brave News Search Scraper do?

The Actor opens Brave News in a hardened Chromium session, searches each supplied query, parses the rendered result cards, and saves one dataset row per unique destination URL.

For every result, it preserves:

- the query and per-query rank;
- headline and publisher;
- relative or absolute publication time;
- normalized publication timestamp when it can be derived;
- article destination URL and source domain;
- Brave's visible snippet and thumbnail when available;
- the exact Brave result-page URL;
- country, language, freshness, and retrieval context.

It stays within search-result metadata. It does not visit publisher articles or claim to return full article bodies.

### Who is it for?

#### Media monitoring and PR teams

Track company, executive, product, campaign, and issue coverage. Schedule daily queries and compare rank, source mix, or headline changes over time.

#### Researchers and journalists

Collect a reproducible set of ranked articles from an independent search index. Keep the source URL and retrieval timestamp for an audit trail.

#### Competitive-intelligence teams

Monitor competitor launches, funding, partnerships, litigation, hiring, and market commentary with multiple precise searches in one run.

#### RAG and AI-agent builders

Feed fresh headlines, snippets, dates, and direct URLs into retrieval pipelines. Use the records for discovery, then let a separate authorized article extractor fetch full text only where needed.

#### Data and automation engineers

Schedule the Actor, stream dataset items through webhooks, or call it through the Apify API and MCP.

### Why use Brave News instead of another news index?

Brave operates an independent search index and can surface a different mix and ranking of sources than Google or Bing. That makes it valuable both as a primary discovery source and as a comparison layer.

- 🧭 **Independent rankings:** compare what Brave surfaces for the same keyword.
- 🔐 **No user search profile required:** the Actor uses anonymous public results.
- 🧩 **Structured context:** every row includes query, rank, localization, and source page.
- 📅 **Repeatable monitoring:** run the same query set on a schedule.
- 📤 **Portable output:** export JSON, CSV, Excel, XML, RSS, or Parquet from Apify.

### What Brave News data can you extract?

| Field | Type | Meaning |
| --- | --- | --- |
| `query` | string | Original keyword search |
| `rank` | number | Position within that query |
| `headline` | string | Article headline shown by Brave |
| `url` | URL | Direct publisher destination |
| `publisher` | string | Source or publisher label |
| `publicationTimeText` | string | Brave's visible date or relative time |
| `publishedAt` | ISO date | Parsed or estimated timestamp when available |
| `snippet` | string | Search-result summary |
| `thumbnailUrl` | URL | Brave-hosted thumbnail when present |
| `sourceDomain` | string | Destination hostname |
| `sourceUrl` | URL | Exact Brave News result page |
| `country` | string | Ranking country requested |
| `language` | string | Search language requested |
| `freshness` | string | Requested recency window |
| `retrievedAt` | ISO date | Actor retrieval timestamp |

Optional fields are omitted when Brave does not show them; the Actor does not invent missing metadata.

### How to scrape Brave News in 5 steps

1. Open the Actor input form.
2. Add one or more searches under **News search queries**.
3. Choose the maximum articles per query, country, language, and freshness.
4. Click **Start** and wait for the dataset to fill.
5. Download the results or connect the dataset to your workflow.

A small first run with one query and 10 articles normally finishes well within two minutes.

### Input parameters

#### News search queries

`queries` accepts 1–20 non-empty strings. Each query can contain up to 400 characters and 50 words.

Brave operators are useful for precise monitoring:

- `"exact phrase"` for an exact phrase;
- `site:reuters.com climate technology` for one publisher;
- `electric vehicles -sports` to exclude a term;
- `Acme Corp funding` for a brand and event combination.

#### Maximum articles per query

`maxResultsPerQuery` ranges from 1 to 200. Use 10–20 for quick checks and larger limits only when you need deeper pagination.

#### Country and language

`country` is a two-letter code such as `US`, `GB`, `DE`, or `AU`. `language` accepts Brave search language codes such as `en`, `de`, `fr`, `es`, or `pt-br`.

#### Freshness

Choose `any`, `day`, `week`, `month`, or `year`. Freshness is applied by Brave before the Actor parses result cards.

#### Safe Search

Choose `off`, `moderate`, or `strict`. The default is `moderate`.

#### Proxy and retries

Direct browser access is the default and avoids proxy bandwidth costs. If Brave challenges a run, enable Apify Proxy or provide custom proxy URLs. `maxRequestRetries` controls bounded fresh-session retries.

### Example input

```json
{
  "queries": [
    "artificial intelligence regulation",
    "site:reuters.com semiconductor supply chain"
  ],
  "maxResultsPerQuery": 25,
  "country": "US",
  "language": "en",
  "freshness": "week",
  "safeSearch": "moderate",
  "maxRequestRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### Example output

```json
{
  "query": "artificial intelligence regulation",
  "rank": 1,
  "headline": "Lawmakers set out a new framework for artificial intelligence",
  "url": "https://example.com/news/ai-framework",
  "publisher": "Example News",
  "publicationTimeText": "2 hours ago",
  "publishedAt": "2026-07-18T00:30:00.000Z",
  "snippet": "The framework outlines rules for high-risk AI systems...",
  "thumbnailUrl": "https://imgs.search.brave.com/example",
  "sourceDomain": "example.com",
  "sourceUrl": "https://search.brave.com/news?q=artificial+intelligence+regulation&source=news",
  "country": "US",
  "language": "en",
  "freshness": "week",
  "retrievedAt": "2026-07-18T02:30:00.000Z"
}
```

The example illustrates the schema; live headlines and rankings change as Brave refreshes its index.

### How much does it cost to scrape Brave News?

This Actor uses pay-per-event pricing:

- **$0.005** when a search run starts;
- a tiered amount for each unique article saved.

The formula-derived BRONZE article price is **$0.00010108 per article**. FREE is $0.00011625; SILVER, GOLD, PLATINUM, and DIAMOND receive progressively larger volume discounts. Platform compute is included in PPE pricing for supported plans.

At BRONZE, a 20-article run costs about **$0.00702**: one $0.005 start plus 20 article events. Check the live pricing tab before a large scheduled workflow because the Store price is authoritative.

### Tips for better Brave News results

- 🎯 Use specific entity and event terms instead of one broad noun.
- 🧪 Compare multiple query variants in the same run.
- 🏷️ Add `site:` when monitoring one publisher.
- 🕒 Use `day` or `week` for alerts and `month` or `any` for research.
- 🌍 Match country and language to the market you are studying.
- 📉 Start with 10–20 articles before increasing pagination.
- 🔁 Schedule repeat runs and compare datasets by query plus URL.

### Monitoring brands and competitors

A useful daily query set might include:

```json
{
  "queries": [
    "Acme Corp",
    "Acme Corp product launch",
    "Acme Corp funding OR acquisition",
    "Acme competitor partnership"
  ],
  "maxResultsPerQuery": 40,
  "freshness": "day"
}
```

Use a webhook or automation to alert only on destination URLs not seen in your previous run.

### Integrations and workflow patterns

#### Google Sheets or Airtable watchlist

Schedule the Actor, export rows, and upsert by `query + url`. Analysts get a shared watchlist without copying search pages manually.

#### Slack or Microsoft Teams alerts

Send new day-filtered results to a webhook. Include publisher, headline, publication time, and direct URL in the message.

#### RAG discovery pipeline

Use Brave records as the discovery stage. Filter by domain and freshness, then pass selected URLs to a separate article extractor that respects publisher access rules.

#### BigQuery, Snowflake, or PostgreSQL

Store recurring snapshots and analyze source share, headline themes, rank volatility, and coverage velocity.

#### Zapier and Make

Trigger a scheduled Actor run, wait for completion, iterate dataset items, and route matches into CRM, email, or incident workflows.

### Use Brave News Search Scraper with the Apify API

The Actor ID is `automation-lab/brave-news-search-scraper`.

#### JavaScript / Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/brave-news-search-scraper').call({
  queries: ['climate technology funding'],
  maxResultsPerQuery: 20,
  country: 'US',
  language: 'en',
  freshness: 'week'
});
const items = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/brave-news-search-scraper').call(run_input={
    'queries': ['climate technology funding'],
    'maxResultsPerQuery': 20,
    'country': 'US',
    'language': 'en',
    'freshness': 'week',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~brave-news-search-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["climate technology funding"],
    "maxResultsPerQuery": 20,
    "freshness": "week"
  }'
```

### Use Brave News Search Scraper with MCP

Apify MCP lets Claude Code and other compatible clients run the Actor as a tool.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/brave-news-search-scraper"
```

#### Claude Desktop, Cursor, or VS Code

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/brave-news-search-scraper"
    }
  }
}
```

#### Specific MCP example prompts

Try these exact prompts:

- “Search Brave News for semiconductor export controls from the past week.”
- “Find the top 30 UK news results for offshore wind investment.”
- “Monitor these three competitors and return only Reuters or Bloomberg links.”

### Scheduling and change detection

Create an Apify schedule for hourly, daily, or weekly runs. For change detection:

1. keep a named store or external table of seen URLs;
2. compare the newest dataset against that set;
3. notify on unseen `query + url` combinations;
4. retain `rank` and `retrievedAt` for trend analysis.

The Actor itself returns a fresh snapshot and does not maintain cross-run alert state.

### Reliability and proxy guidance

Brave can rate-limit automated traffic. The Actor uses a normal browser fingerprint, conservative page pacing, and browser-session rotation.

If a run reports a Brave challenge:

- enable Apify Proxy in the input;
- try the SHADER group first because it is cheaper than residential traffic;
- use residential only when datacenter sessions are consistently challenged;
- keep retries bounded rather than repeatedly loading a blocked page.

The Actor fails non-zero when every query encounters extraction failure, so schedules and integrations do not mistake a challenge page for successful empty data.

### Limitations

- Rankings and result counts change continuously.
- Brave may show fewer records than requested for narrow searches.
- `publishedAt` is estimated for relative labels such as “2 hours ago.”
- Some cards have no thumbnail or machine-parseable publication date.
- The Actor does not fetch article bodies, authors, paywalled content, comments, or publisher analytics.
- Country and language influence ranking but do not guarantee every result originates in that country or language.
- Brave can change its page structure or anti-automation controls.

### Is scraping Brave News legal?

The Actor accesses publicly visible search-result metadata without logging in. Web scraping legality depends on jurisdiction, intended use, the data collected, and applicable terms.

You are responsible for:

- having a lawful purpose for collection and processing;
- respecting Brave and publisher terms;
- avoiding personal-data misuse;
- honoring copyright, database, and privacy rules;
- applying appropriate retention and access controls.

Search snippets are discovery metadata, not a license to republish full articles. Consult qualified counsel for regulated or high-risk use cases.

### Troubleshooting

#### Why did the Actor return fewer articles than requested?

The query or freshness window may genuinely have fewer unique results. Broaden the query, use a longer freshness window, or lower the expected count. Duplicate destination URLs are intentionally removed per query.

#### Why did the run fail with a Brave challenge?

Enable `proxyConfiguration`, start with SHADER, and retry. If your environment has repeated challenges, rotate sessions or use an appropriate residential country. The logs state whether a challenge or navigation failure caused the retry.

#### Why is `publishedAt` missing?

Brave sometimes shows publication text that cannot be safely normalized. The original `publicationTimeText` remains available.

#### Why are there no full article bodies?

V1 deliberately stays on Brave's news-result metadata. Use a separate publisher-page extractor where you have permission to retrieve full text.

### Frequently asked questions

#### Does this Actor require a Brave Search API key?

No. It uses the anonymous public Brave News web interface.

#### Can I search multiple keywords in one run?

Yes. Add up to 20 unique queries. Rank resets to 1 for each query.

#### Can I filter one publisher?

Yes. Use Brave's `site:` operator, for example `site:npr.org renewable energy`.

#### Can I export CSV or Excel?

Yes. Open the dataset and choose CSV, Excel, JSON, XML, RSS, or another supported format.

#### Can I schedule monitoring?

Yes. Apify schedules can run the same input repeatedly. Use webhooks or integrations to notify on new URLs.

#### Does Safe Search remove all sensitive content?

No automated filter is perfect. Select `strict` for stronger filtering and review outputs for your use case.

### Related news scrapers

Use another Automation Lab Actor when you need a different index or source:

- [Google News Scraper](https://apify.com/automation-lab/google-news-scraper) — Google News RSS search and topics.
- [Bing News Scraper](https://apify.com/automation-lab/bing-news-scraper) — compare Microsoft/Bing news rankings.
- [GDELT Global News Search Scraper](https://apify.com/automation-lab/gdelt-global-news-search-scraper) — global event and news discovery.
- [Reuters Latest News Feed Scraper](https://apify.com/automation-lab/reuters-latest-news-feed-scraper) — source-specific Reuters monitoring.
- [Yahoo News Search Scraper](https://apify.com/automation-lab/yahoo-news-search-scraper) — another ranked news-search surface.

Combining independent indexes can improve source coverage and reveal ranking differences.

### Support

If a valid query repeatedly fails, open an Actor issue with:

- the run URL;
- your input with secrets removed;
- the country and language used;
- whether proxy configuration was enabled;
- the expected result page or example article.

That evidence makes challenge and parser changes faster to diagnose.

# Actor input Schema

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

Enter one or more keyword searches. Brave search operators such as quotes, minus terms, and site: filters are supported.

## `maxResultsPerQuery` (type: `integer`):

Stop after this many unique ranked news articles for each query.

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

Two-letter country code used by Brave to localize rankings, for example US, GB, DE, or AU.

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

Brave search language code, for example en, de, fr, es, or pt-br.

## `freshness` (type: `string`):

Restrict results to Brave's selected recency window.

## `safeSearch` (type: `string`):

Choose Brave's filtering level for explicit or suggestive content.

## `maxRequestRetries` (type: `integer`):

Number of fresh browser sessions to try after a challenge or navigation failure.

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

Optional Apify or custom proxy. Direct access is used when disabled; enable a proxy if Brave challenges your run.

## Actor input object example

```json
{
  "queries": [
    "artificial intelligence"
  ],
  "maxResultsPerQuery": 10,
  "country": "US",
  "language": "en",
  "freshness": "any",
  "safeSearch": "moderate",
  "maxRequestRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "queries": [
        "artificial intelligence"
    ],
    "maxResultsPerQuery": 10,
    "country": "US",
    "language": "en",
    "freshness": "any",
    "safeSearch": "moderate",
    "maxRequestRetries": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/brave-news-search-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 = {
    "queries": ["artificial intelligence"],
    "maxResultsPerQuery": 10,
    "country": "US",
    "language": "en",
    "freshness": "any",
    "safeSearch": "moderate",
    "maxRequestRetries": 2,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/brave-news-search-scraper").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 '{
  "queries": [
    "artificial intelligence"
  ],
  "maxResultsPerQuery": 10,
  "country": "US",
  "language": "en",
  "freshness": "any",
  "safeSearch": "moderate",
  "maxRequestRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/brave-news-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/brave-news-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Brave News Search Scraper",
        "description": "Search Brave News by keyword and export ranked headlines, publishers, publication times, snippets, destination URLs, and thumbnails for monitoring, research, or RAG.",
        "version": "0.1",
        "x-build-id": "f7YbEgfWK2RC2iR0m"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~brave-news-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-brave-news-search-scraper",
                "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/automation-lab~brave-news-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-brave-news-search-scraper",
                "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/automation-lab~brave-news-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-brave-news-search-scraper",
                "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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "🔎 News search queries",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "Enter one or more keyword searches. Brave search operators such as quotes, minus terms, and site: filters are supported.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum articles per query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Stop after this many unique ranked news articles for each query.",
                        "default": 20
                    },
                    "country": {
                        "title": "🌍 Country",
                        "type": "string",
                        "description": "Two-letter country code used by Brave to localize rankings, for example US, GB, DE, or AU.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Search language",
                        "type": "string",
                        "description": "Brave search language code, for example en, de, fr, es, or pt-br.",
                        "default": "en"
                    },
                    "freshness": {
                        "title": "Article freshness",
                        "enum": [
                            "any",
                            "day",
                            "week",
                            "month",
                            "year"
                        ],
                        "type": "string",
                        "description": "Restrict results to Brave's selected recency window.",
                        "default": "any"
                    },
                    "safeSearch": {
                        "title": "🛡️ Safe Search",
                        "enum": [
                            "off",
                            "moderate",
                            "strict"
                        ],
                        "type": "string",
                        "description": "Choose Brave's filtering level for explicit or suggestive content.",
                        "default": "moderate"
                    },
                    "maxRequestRetries": {
                        "title": "Browser session retries",
                        "minimum": 0,
                        "maximum": 4,
                        "type": "integer",
                        "description": "Number of fresh browser sessions to try after a challenge or navigation failure.",
                        "default": 2
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify or custom proxy. Direct access is used when disabled; enable a proxy if Brave challenges your run.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```