# Brave Search Scraper (`aerodynamic_tripod/brave-search-scraper`) Actor

Scrape Brave Search results in bulk with organic rankings, sponsored results, pagination, country and Safe Search controls, target-domain tracking, and structured datasets. HTTP-only, fast, and built for SEO research and SERP monitoring.

- **URL**: https://apify.com/aerodynamic\_tripod/brave-search-scraper.md
- **Developed by:** [SearchShark Tools](https://apify.com/aerodynamic_tripod) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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 Search Scraper

**Brave Search Scraper** lets you extract **structured organic and sponsored search results from Brave Search** for SEO research, SERP monitoring, competitor analysis, and automation.

Collect **real observed search rankings**, titles, URLs, domains, descriptions, publication dates, ads, sitelinks, and more — without manually checking Brave Search.

- 🎯 **Track organic rankings:** preserve the observed organic position for every search result
- 📊 **Analyze competitors:** see which domains and pages rank for your target searches
- 🔎 **Research SERPs:** collect structured Brave Search results across many queries
- 📣 **Capture sponsored results:** extract ads separately without affecting organic rankings
- 🌐 **Track target domains:** find the best observed position of specific websites
- ⚡ **Run searches in bulk:** process many independent search terms in one Actor run
- 🧹 **Avoid duplicate organic results:** URL-based deduplication keeps output cleaner
- 🔌 **Automate workflows:** export results through Apify Dataset, API, integrations, or downstream applications

***

### 📦 What data does Brave Search Scraper extract?

| | |
| --- | --- |
| 🔍 **Search query** | 🏆 **Organic rank** |
| 📄 **Page number** | 📌 **Position on page** |
| 🦁 **Brave SERP position** | 📰 **Result title** |
| 🔗 **Destination URL** | 🌐 **Domain** |
| 🧭 **Displayed URL** | 📝 **Description** |
| 📅 **Published date** | 🖼 **Favicon** |
| 🖼 **Thumbnail** | 🔗 **Sitelinks** |
| 🧩 **Result type** | 📣 **Sponsored status** |
| 📢 **Sponsored position** | 🆔 **Advertising metadata** |
| 🌎 **Country setting** | 🛡 **Safe Search setting** |
| 🔎 **Source URL** | 🕒 **Scrape timestamp** |

> **Missing fields are returned as `null`.** The Actor does **not invent information** that Brave Search does not expose.

***

### 🚀 Features

Brave Search Scraper is designed for **SEO research, SERP intelligence, competitor monitoring, and structured search-data collection**.

- **Bulk search terms:** process up to 1,000 queries in one Actor run
- **Up to 100 organic results per search term**
- **Organic ranking preservation:** results retain their actual observed organic position
- **Sponsored result extraction:** ads are collected separately from organic results
- **Sponsored results do not affect organic rank**
- **Automatic pagination:** continue through Brave result pages until the requested limit is reached
- **Country controls:** apply a two-letter country setting such as `us`, `gb`, `ca`, or `au`
- **Safe Search controls:** choose `off`, `moderate`, or `strict`
- **Target-domain tracking:** monitor up to 100 domains in each run
- **Per-query URL deduplication:** duplicate organic destination URLs are not returned repeatedly
- **Structured supplemental datasets:** target-domain and search-run summaries are generated automatically
- **Retry handling:** temporary request failures are retried automatically
- **Partial failure protection:** one failed query does not discard successful queries
- **HTTP-only architecture:** normal searches do not require browser automation
- **API-friendly output:** structured results are easy to consume from other applications

***

## ⬇️ Input

You can configure Brave Search Scraper directly from the **Apify Console** or send the input programmatically through the **Apify API**.

***

### 🔎 Search terms

Add one or more searches you want to run on Brave Search.

Example:

```text
plumber los angeles
dentist los angeles
hvac contractor los angeles
```

**Each search term is processed independently.**

You can provide:

```text
Minimum: 1 search term
Maximum: 1,000 search terms
Maximum length per term: 512 characters
```

For example:

```text
best crm software
emergency plumber chicago
seo agency new york
site:example.com marketing
```

Brave search operators can be included directly in the search term when supported by Brave Search.

***

### 🔢 Maximum results per search

Set the maximum number of **unique organic results** to collect for each search term.

```text
Minimum: 1
Default: 100
Maximum: 100
```

For example:

```text
Search terms:
plumber los angeles
dentist los angeles

Maximum results per search:
100
```

can return up to:

```text
100 organic results for plumber los angeles
+
100 organic results for dentist los angeles
=
200 organic results
```

Sponsored rows may also be included in the default Dataset, so the **total Dataset row count can be higher than the requested organic-result maximum**.

The requested number is a **maximum, not a guarantee**.

If Brave stops exposing new organic results before the requested limit is reached, the Actor stops naturally.

***

### 🌎 Country

Choose the country context applied to Brave Search.

Use a lowercase two-letter country code.

Examples:

```text
us
gb
ca
au
de
fr
```

Default:

```text
us
```

The country setting is applied to **every search term in the run**.

> Search results can still vary over time because search-engine ranking is dynamic.

***

### 🛡 Safe Search

Choose the Brave Search Safe Search setting.

Available values:

```text
off
moderate
strict
```

Default:

```text
moderate
```

This setting is applied to every search in the run.

***

### 🎯 Target domains

Optionally provide domains you want to track across the organic search results.

Example:

```text
yelp.com
angi.com
example.com
```

You can track:

```text
Maximum: 100 target domains
```

Target-domain tracking **does not make additional website requests**.

It only analyzes the organic Brave results already collected.

#### Subdomain matching

A subdomain can match its parent target domain.

For example:

```text
Target:
example.com

Result:
blog.example.com

Match:
Yes
```

But similar-looking domains are not treated as the same website.

For example:

```text
roto-rooter.com
rotorooter.com
```

are considered **different domains**.

***

### 🌐 Proxy configuration

**Apify Proxy can be used for network requests.**

The Actor uses ordinary HTTP requests and does not require browser automation for normal Brave Search result extraction.

***

### 🧪 Example input

```json
{
  "searchTerms": [
    "plumber los angeles",
    "dentist los angeles",
    "hvac contractor los angeles"
  ],
  "maxResultsPerSearch": 50,
  "country": "us",
  "safeSearch": "moderate",
  "targetDomains": [
    "yelp.com",
    "angi.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

***

## ⬆️ Output

Brave Search Scraper creates **three structured datasets**:

```text
default
target_domain_summary
search_summary
```

The main search results are stored in the Actor's **default Dataset**.

You can access the output through:

```text
Output
Storage
Apify API
Integrations
```

***

## 📊 Main results Dataset

The `default` Dataset contains both:

```text
organic
sponsored
```

search results.

***

### 🔎 Example organic result

```json
{
  "query": "plumber los angeles",
  "rank": 1,
  "page": 1,
  "pagePosition": 1,
  "braveSerpPosition": 1,
  "sponsoredPosition": null,
  "title": "Example Plumbing Company",
  "url": "https://www.example.com/plumbing",
  "displayedUrl": "example.com › plumbing",
  "domain": "example.com",
  "description": "Professional plumbing services in Los Angeles...",
  "publishedDate": null,
  "favicon": "https://example.com/favicon.ico",
  "thumbnail": null,
  "sitelinks": [
    {
      "title": "Emergency Plumbing",
      "url": "https://www.example.com/emergency"
    }
  ],
  "resultType": "organic",
  "isSponsored": null,
  "adPlacementId": null,
  "adCreativeInstanceId": null,
  "adCreativeSetId": null,
  "adCampaignId": null,
  "adAdvertiserId": null,
  "country": "us",
  "safeSearch": "moderate",
  "sourceUrl": "https://search.brave.com/search?q=plumber+los+angeles",
  "scrapedAt": "2026-09-08T04:32:09.000Z"
}
```

> The values above are illustrative. Actual search results depend on what Brave Search returns at the time of the run.

***

### 📣 Example sponsored result

Sponsored results are stored in the same default Dataset with:

```text
resultType: sponsored
isSponsored: true
rank: null
pagePosition: null
```

Example:

```json
{
  "query": "plumber los angeles",
  "rank": null,
  "page": 1,
  "pagePosition": null,
  "braveSerpPosition": 2,
  "sponsoredPosition": 1,
  "title": "Example Sponsored Plumbing Result",
  "url": "https://www.example-advertiser.com/",
  "displayedUrl": "example-advertiser.com",
  "domain": "example-advertiser.com",
  "description": "Book plumbing service today.",
  "publishedDate": null,
  "resultType": "sponsored",
  "isSponsored": true,
  "country": "us",
  "safeSearch": "moderate"
}
```

***

### 🏆 Organic rank

One of the most important fields returned by the Actor is:

```text
rank
```

This represents:

> **The observed organic Brave Search position for that query during the scrape.**

For example:

```text
Result A → rank 1
Result B → rank 2
Result C → rank 3
```

Only **organic web results** increment this rank.

Sponsored results do **not** consume an organic rank.

***

### 🦁 Brave SERP position

The Actor also preserves:

```text
braveSerpPosition
```

This is Brave's observed **mixed SERP position** when available.

A Brave results page can contain different elements such as:

```text
Sponsored results
Organic web results
Other search modules
```

Because these can be mixed together, `braveSerpPosition` may differ from the organic `rank`.

For SEO ranking analysis, use:

```text
rank
```

For the observed mixed Brave SERP position, use:

```text
braveSerpPosition
```

***

### 📄 Page and page position

Organic results also include:

```text
page
pagePosition
```

Example:

```text
rank: 39
page: 2
pagePosition: 20
```

This tells you both the **global organic position** and where the result appeared on the fetched Brave page.

***

### 🧹 Organic URL deduplication

Organic results are deduplicated **within each search query** using normalized destination URLs.

The Actor normalizes URLs by handling things such as:

```text
Hostname casing
Default ports
URL fragments
Root slash equivalence
Common tracking parameters
```

Common marketing parameters removed during comparison include:

```text
utm_source
utm_medium
utm_campaign
utm_term
utm_content
gclid
fbclid
msclkid
```

Meaningful paths and query parameters are preserved.

#### Ranking is not renumbered after deduplication

Suppose Brave exposes:

```text
Rank 1 → Website A
Rank 2 → Website B
Rank 3 → duplicate of Website A
Rank 4 → Website C
```

The Actor may return:

```text
Website A → rank 1
Website B → rank 2
Website C → rank 4
```

It does **not** rename Website C to rank 3.

This preserves the **real observed organic ranking**.

That also means a run requesting 100 unique organic results can occasionally have a highest observed rank greater than 100.

***

## 🎯 Target-domain summary

When `targetDomains` are supplied, the Actor creates a separate:

```text
target_domain_summary
```

Dataset.

Each row contains:

```text
query
targetDomain
bestRank
matchingResults
```

Example:

```json
{
  "query": "plumber los angeles",
  "targetDomain": "yelp.com",
  "bestRank": 1,
  "matchingResults": 3
}
```

This means `yelp.com` appeared three times among the collected organic results and its best observed organic rank was `1`.

If a domain does not appear:

```json
{
  "query": "plumber los angeles",
  "targetDomain": "example.com",
  "bestRank": null,
  "matchingResults": 0
}
```

#### Why this is useful

Use the target-domain summary to quickly answer questions such as:

```text
Where does my website rank?
Does a competitor appear?
What is the competitor's best position?
How many pages from that domain appear?
```

without manually filtering the entire result Dataset.

***

## 📋 Search summary

The Actor also creates:

```text
search_summary
```

This provides **one summary row for each search term**.

Fields include:

```text
query
status
failureStatus
stopReason
resultsCollected
sponsoredResultsCollected
pagesFetched
httpStatus
errorMessage
challengeMarkers
startedAt
finishedAt
```

Example:

```json
{
  "query": "plumber los angeles",
  "status": "success",
  "failureStatus": null,
  "stopReason": "max_results_reached",
  "resultsCollected": 20,
  "sponsoredResultsCollected": 2,
  "pagesFetched": 2,
  "httpStatus": 200,
  "errorMessage": null,
  "challengeMarkers": [],
  "startedAt": "2026-09-08T04:32:07.000Z",
  "finishedAt": "2026-09-08T04:32:11.000Z"
}
```

***

### ✅ Search statuses

A query can finish with statuses such as:

```text
success
partial
no_results
rate_limited
blocked
http_error
parse_error
retry_exhausted
```

This makes it easier to determine whether a search completed normally or encountered a network/search-engine issue.

***

## 📄 Pagination

Brave Search Scraper **automatically requests additional search-result pages**.

The search can stop when:

- 🎯 **Requested maximum results reached**
- 📭 **No organic results are returned**
- 🆕 **No new normalized organic URLs are found**
- 🔁 **A previously observed result page repeats**
- ⚠️ **Request retries are exhausted**
- 🛡 **The defensive page ceiling is reached**
- 🚫 **Brave returns a blocking or rate-limit response**

The current defensive pagination limit is:

```text
10 pages per search term
```

***

## 📅 Published dates

When Brave exposes a publication date, the Actor attempts to extract it into:

```text
publishedDate
```

Examples can include:

```text
May 16, 2018
June 10, 2026
September 26, 2024
today
yesterday
3 days ago
```

When an explicit absolute date is available, it is preferred over a generic relative label when possible.

If Brave does not expose a usable date:

```text
publishedDate: null
```

***

## ⚡ Performance

Brave Search Scraper uses an **HTTP-only architecture** for normal searches.

Instead of launching a full browser, it processes Brave's server-rendered search-result HTML directly.

This generally provides:

```text
Faster startup
Lower memory usage
Lower compute overhead
Efficient bulk searching
```

Search terms can run concurrently while the individual pages of each search are processed in sequence.

***

## 🛡 Reliability

The Actor includes defensive handling for temporary request and parsing problems.

It can detect conditions such as:

```text
HTTP 403
HTTP 429
HTTP 5xx errors
Rate-limit pages
Challenge pages
Parser failures
Network failures
```

Temporary failures can be retried automatically.

The Actor does **not attempt to solve or bypass CAPTCHA or challenge systems**.

If one query fails during a multi-query run, successful queries can still retain their results.

***

## 🔌 API & integrations

Brave Search Scraper can be used programmatically through the **Apify API**.

You can connect results to workflows such as:

- Google Sheets
- Make
- Zapier
- CRMs
- SEO dashboards
- Internal APIs
- Data warehouses
- Competitive intelligence systems
- AI agents
- MCP workflows

The main result rows are stored in the default Dataset, making them easy to consume from another application.

***

## 💡 Example use cases

### 🎯 SEO rank tracking

Search:

```text
emergency plumber los angeles
```

Track:

```text
Your domain
Competitor domains
Best observed ranking
Number of ranking URLs
```

Use `targetDomains` to create a ready-made ranking summary.

***

### 📊 Competitor research

Run searches such as:

```text
best crm software
email marketing software
sales automation platform
```

Analyze:

```text
Which domains rank most often
Which pages hold top positions
Which competitors advertise
What titles and descriptions competitors use
```

***

### 🔎 SERP research

Collect structured results for many related searches:

```text
seo agency los angeles
seo company los angeles
local seo los angeles
technical seo agency
```

Use the output to study:

```text
Ranking patterns
Domain visibility
SERP overlap
Competitor coverage
Search intent
```

***

### 📣 Sponsored result research

Sponsored Brave Search results are captured separately from organic rankings.

Use them to research:

```text
Which advertisers appear
Sponsored landing pages
Ad headlines
Ad descriptions
Advertising visibility
```

***

### 🌎 Country-specific research

Run the same search under different country settings.

Example:

```text
us
gb
ca
au
```

This can help compare how Brave Search results differ between country contexts.

***

### 🎯 Target-domain monitoring

Provide:

```text
example.com
competitor.com
anothercompetitor.com
```

and let the Actor produce:

```text
Best observed rank
Matching organic results
Per-query domain visibility
```

***

## ⚠️ Current limitations

The current version focuses on **reliable Brave web-search result extraction**.

It does **not currently perform**:

```text
Image-search scraping
News-search scraping
Video-search scraping
Local/map-result extraction
Full webpage crawling of every result
Email extraction from ranking websites
Social-profile enrichment
Search-result personalization by user account
CAPTCHA solving
Browser fingerprint spoofing
```

The Actor does not visit every result website unless a future feature explicitly adds that behavior.

***

## ❓ FAQ

### How does Brave Search Scraper work?

The Actor sends normal HTTP requests to Brave Search for each supplied query.

It then:

```text
Fetches search-result pages
Parses organic web results
Parses sponsored results
Tracks organic ranking
Normalizes URLs
Removes duplicate organic URLs
Automatically paginates
Tracks requested target domains
Creates structured summary datasets
```

***

### How many results can I scrape?

The current maximum is:

```text
100 unique organic results per search term
```

Brave may expose fewer results.

The requested number is therefore a **maximum rather than a guarantee**.

***

### How many searches can I run at once?

You can provide up to:

```text
1,000 search terms
```

in a single Actor input.

Each search term is handled as its own search context.

***

### Are sponsored results included?

**Yes.**

Sponsored results are stored in the default Dataset with:

```text
resultType: sponsored
isSponsored: true
```

They are kept separate from organic ranking logic.

***

### Do ads affect the organic rank?

**No.**

Organic `rank` counts only organic web results.

Sponsored results have:

```text
rank: null
pagePosition: null
```

and receive their own:

```text
sponsoredPosition
```

***

### Why do rank numbers sometimes have gaps?

Because rank represents the **observed organic Brave Search position before URL deduplication**.

If an organic destination URL appears again later, the duplicate can be removed while subsequent rankings remain unchanged.

For example:

```text
Returned row 99
rank 100

Returned row 100
rank 101
```

can be valid.

The Actor preserves the observed SERP ranking instead of renumbering results.

***

### What is the difference between `rank` and `braveSerpPosition`?

Use:

```text
rank
```

for the **organic-only ranking**.

Use:

```text
braveSerpPosition
```

for Brave's observed **mixed SERP position** when available.

Sponsored or other Brave modules can cause these numbers to differ.

***

### Why are some fields null?

**Brave does not expose every field for every search result.**

The Actor returns:

```text
null
```

when a value cannot be extracted confidently.

It does not fabricate missing values.

***

### Can I track my website or competitors?

**Yes.**

Add domains to:

```text
targetDomains
```

The `target_domain_summary` Dataset will report:

```text
bestRank
matchingResults
```

for every query and target domain.

***

### Does target-domain tracking make extra requests?

**No.**

Target-domain tracking analyzes the organic search results already collected by the Actor.

It does not separately visit the target website.

***

### Can I use Brave Search Scraper through an API?

**Yes.**

Every Actor can be started through the **Apify API**, and its datasets can be consumed programmatically.

This makes the Actor suitable for automated SEO, SERP-monitoring, and competitive-intelligence workflows.

***

### Can I export the results?

**Yes.**

Apify Dataset results can be exported in supported formats such as:

```text
JSON
CSV
Excel
XML
HTML
```

***

### Does this Actor require a browser?

**Not for the normal search workflow.**

Brave Search Scraper uses direct HTTP requests and HTML parsing instead of launching browser automation for standard searches.

***

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

**No Brave Search API key is required for the current scraping workflow.**

The Actor works from the public Brave Search result pages rather than the Brave Search API.

***

### Is this Actor affiliated with Brave?

**No.**

This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Brave Software**.

Brave and related names or marks belong to their respective owners.

***

## 💵 Pricing

Brave Search Scraper uses **pay-per-event pricing**.

The main billable result event is each row written to the Actor's default Dataset.

This means both:

```text
Organic result rows
Sponsored result rows
```

can count as billable result events.

The current Store pricing is shown directly on the Actor page before a run is started.

Your Apify platform usage is handled according to the pricing shown by Apify for the Actor.

***

## 🧭 Recommended workflow

For useful SEO coverage, use **distinct search intents and keywords** rather than large numbers of nearly identical queries.

Good:

```text
emergency plumber los angeles
commercial plumber los angeles
water heater repair los angeles
drain cleaning los angeles
```

Potentially repetitive:

```text
plumber los angeles
plumbers los angeles
plumbing los angeles
plumbing company los angeles
```

Closely related searches can naturally return many of the same websites.

***

## 💬 Feedback & support

Found a bug or have a feature request?

Use the Actor's **Issues** tab on Apify.

Useful future additions may include:

```text
More Brave Search verticals
Additional localization controls
Advanced SERP feature extraction
Ranking-history workflows
Expanded advertising analytics
Additional export summaries
```

***

### 🚀 Brave Search data without the manual searching

Enter your queries, choose your country and Safe Search settings, optionally track target domains, run the Actor, and receive **structured Brave Search data** ready for **SEO research, SERP monitoring, competitor analysis, APIs, and automation**.

# Actor input Schema

## `searchTerms` (type: `array`):

Enter one or more search queries. Each search term is searched independently on Brave Search.

## `maxResultsPerSearch` (type: `integer`):

Maximum number of organic Brave Search results to collect for each search term. Brave may return fewer results if the available result pool is exhausted.

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

Two-letter country code used for Brave Search localization. Examples: us, gb, ca, au.

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

Brave Safe Search level applied to every search.

## `targetDomains` (type: `array`):

Optional domains to track in organic results. Example: yelp.com or angi.com. This does not make additional Brave Search requests.

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

Proxy settings used for Brave Search requests.

## Actor input object example

```json
{
  "searchTerms": [
    "plumber los angeles"
  ],
  "maxResultsPerSearch": 100,
  "country": "us",
  "safeSearch": "moderate",
  "targetDomains": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Organic and sponsored Brave Search result rows.

## `targetDomainSummary` (type: `string`):

Organic ranking summary for each requested target domain and search query.

## `searchSummary` (type: `string`):

Per-query completion status, result counts, page counts, and failure information.

# 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("aerodynamic_tripod/brave-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 = {}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,aerodynamic_tripod/brave-search-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/LcGbFT5hSKA3P8SVp/builds/3CVTAkmyfr7reLBby/openapi.json