# Semrush Scraper - Authority Score, Traffic & Competitors (`topapi/semrush-scraper`) Actor

Scrape Semrush website data without an account: Authority Score, visits, organic and paid traffic, backlinks, referring domains, ranks, top countries and keywords, competitors, traffic sources, AI traffic and top-websites rankings. From $0.90 per 1,000 websites.

- **URL**: https://apify.com/topapi/semrush-scraper.md
- **Developed by:** [Top Api](https://apify.com/topapi) (community)
- **Categories:** SEO tools, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 websites

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Semrush Scraper do?

**Semrush Scraper** reads Semrush's public website data for any list of domains: **Authority Score, monthly visits and their change, pages per visit, time on site, bounce rate, desktop / mobile split, worldwide / country / industry rank, organic and paid search traffic, backlinks, referring domains, Google penalty risk, the top 5 countries, the top 5 organic keywords (position, volume, CPC, intent), competitors, traffic sources and destinations, AI-assistant traffic and 3-6 months of history**. It also returns **competitor rows** (every website on a domain's Semrush competitors page, with its own metrics) and Semrush's **top-websites rankings** (the 100 most visited websites of 240 countries x 111 industries). One row per website, competitor or ranking entry. SEO agencies, investors, lead-scoring and market-research teams use it as a **Semrush API alternative**.

- 🏅 **Authority**: Semrush Authority Score, backlinks and referring domains with the month's change, Google penalty risk.
- 🚦 **Traffic**: exact monthly visits (not "232.54M"), engagement, desktop / mobile, organic and paid search traffic.
- 🌍 **Countries and keywords**: the 5 countries and 5 organic keywords that bring the most traffic.
- 🥊 **Competitors**: the closest competitors on every row; competitor rows add each competitor's Authority Score, visits, ranks and engagement.
- 🔀 **Traffic journey and AI traffic**: where visitors come from and go next, and how much ChatGPT, Claude, Grok and other AI sites send.
- 🏆 **Top websites** by country and industry, with exact visits, month-over-month and year-over-year change.
- 🔑 **No Semrush account, no API key, no subscription**; domains Semrush does not publish are listed and never charged.
- 🔔 **Monitor mode**, schedules, API, MCP, Make / Zapier / n8n.

### What data can you get from Semrush?

| | | |
|---|---|---|
| 🏅 Authority Score `authority_score` | 🔗 Backlinks `backlinks` | 🌐 Referring domains `referring_domains` |
| 🚦 Monthly visits `visits` | 🔎 Organic traffic `organic_traffic` | 💵 Paid traffic `paid_traffic` |
| 🌍 World rank `global_rank` | 🗺️ Country rank `country_rank` | 📂 Industry rank `category_rank` |
| ⏱️ Time on site `time_on_site_seconds` | 📄 Pages per visit `pages_per_visit` | ↩️ Bounce rate `bounce_rate_percent` |
| 📱 Desktop / mobile `desktop_visits`, `mobile_visits` | 🌍 Top 5 countries `top_countries` | 🔑 Top 5 keywords `top_keywords` |
| 🥊 Competitors `competitors` | 🔀 Traffic sources `traffic_sources` | 🤖 AI traffic `ai_traffic` |
| 📅 History `search_traffic_history`, `backlinks_history` | ⚠️ Penalty risk `google_penalty_risk` | 🏷️ Brand, industries `brand_name`, `categories` |
| 🧩 Competitor rows `competitor_of`, `position` | 🏆 Top-websites rows `rank`, `visits_change_yoy_percent` | 🔔 Changes since last run `change_since_last_run` |

### How to scrape Semrush with Semrush Scraper

1. [Create a free Apify account](https://console.apify.com/sign-up) (it comes with free monthly credit).
2. Open **Semrush Scraper** and type your **Domains or URLs**, one per line (`stripe.com`).
3. Tick **Competitor rows** for each domain's competitors, or pick **Top websites: countries** and industries. All of them can run together.
4. Set **Max rows**, and the filters if you want them.
5. Click **Start**, then download the rows as JSON, CSV or Excel, or read them through the API.

### Input

| Parameter | Type | Description |
|---|---|---|
| **🌐 Websites** | | |
| `domains` | array | Domains, website URLs or Semrush pages (`semrush.com/website/stripe.com/overview/`, `.../competitors/`, `semrush.com/trending-websites/us/finance`, any language host). `www.`, case and paths are normalised. |
| `urlsFromFile` | string | A pasted list (text, CSV, JSON) or a public `.csv` / `.json` / `.txt` link, up to 2 MiB. |
| `allTrackedDomains` | boolean | Every website Semrush publishes a page for (about 250,000, from its sitemaps), up to Max rows. Default `false`. |
| `domainSuffixes`, `excludeKeywords` | array | Keep only `.de`, `.co.uk`...; skip domains containing a word. Free, before any page is read. |
| `includeCompetitors` | boolean | One competitor row per website on each domain's competitors page (charged per row). The website row also gets its rank changes in places and Semrush's description. Default `false`. |
| `competitorsOnly` | boolean | Only the competitor rows, no website row. Default `false`. |
| `maxCompetitorsPerDomain` | integer | Competitor rows per domain (Semrush lists 1-10). Default 20 (all). |
| `includeHistory` | boolean | Visits (3 months), device, search traffic, backlinks, referring domains and AI sources (6 months each). Default `true`, free. |
| `includeTopCountries`, `includeTopKeywords`, `includeTrafficSources`, `includeAiTraffic` | boolean | Leave a section out of the rows. Default `true`, free. |
| **🏆 Top websites** | | |
| `locations` | array | `global` (World), `us`, `gb`, `de`... (240 countries). Empty = no rankings. |
| `topWebsitesCategories` | array | `all`, `finance`, `automotive`, `online-services`... (111 industries). |
| `topWebsitesLimit` | integer | Rows per ranking, up to 100. Default 100. |
| `enrichTopWebsites` | boolean | Add each ranked website's full website data to its row (one top-website + one website event). |
| **🔎 Filters** (before the charge) | | |
| `minAuthorityScore`, `maxAuthorityScore`, `minVisits`, `maxVisits`, `minOrganicTraffic`, `onlyCategories`, `onlyCountries` | | Rows that miss them are dropped free. |
| **🔔 Monitoring** | | |
| `monitorMode`, `monitorOutput`, `monitorStoreName` | | Only new or changed rows since the last run with the same name. |
| **⚙️ Run options** | | |
| `maxItems` | integer | Rows for the whole run, all kinds together (0 = no limit). Default 300. |
| `maxConcurrency` | integer | Pages in parallel. Default 8. |
| `proxyConfiguration` | object | Optional; by default the actor reads directly and climbs to Apify datacenter, then residential, only when a route is refused. |

Rival field names work too: `urls`, `targets`, `websites`, `startUrls`, `queries`, `country_top_websites`, `industry_top_websites`, `topWebsitesCountry`, `topWebsitesIndustry`, `rankingCountry`, `rankingIndustry`, `includeCompetitorDetails`, `competitorsPerDomain`, `includeMonthlyHistory`, `onlyWithTrafficEstimate`, `filterCountries`, `filterCategories`, `onlyNew`, `onlyChanged`, `stateKey`, `maxResults`.

#### Input JSON

```json
{
    "domains": ["stripe.com", "github.com", "https://www.notion.so/product"],
    "includeCompetitors": true,
    "locations": ["us", "de"],
    "topWebsitesCategories": ["finance"],
    "topWebsitesLimit": 100
}
```

#### Give the bare domain, not a page

Semrush keeps one page per registrable domain. `https://www.stripe.com/pricing` becomes `stripe.com`; a subdomain without its own page (`docs.github.com`) falls back once to `github.com` and the row says `resolved_from`.

#### Big lists: give the run more memory

At the default 256 MB a run reads about 2.4 websites a second (300 websites in 124 s). At 1,024 MB the same 300 took 32 s and cost the same ($0.0034 of platform usage either way), because the work is CPU-bound and CPU grows with memory. For 1,000+ domains, set **Memory** to 1,024 MB in the run options.

### Output

A real website row (`stripe.com` with `includeCompetitors`, run 2026-10-28; arrays cut to their first entry):

```json
{
  "type": "domain_overview",
  "domain": "stripe.com",
  "url": "https://www.semrush.com/website/stripe.com/overview/",
  "main_country": "US",
  "categories": ["Computer Software and Development", "Finance", "Information Technology", "Online Services"],
  "data_month": "2026-09",
  "authority_score": 79,
  "global_rank": 145,
  "global_rank_trend": "up",
  "global_rank_change_places": 12,
  "country_rank": 145,
  "country_rank_country": "US",
  "category_rank": 3,
  "category_rank_name": "Finance",
  "visits": 232542245,
  "visits_change_percent": 11.79,
  "pages_per_visit": 2.812,
  "time_on_site_seconds": 498,
  "bounce_rate_percent": 61.53,
  "desktop_visits": 125511872,
  "mobile_visits": 107030373,
  "organic_traffic": 4963905,
  "organic_traffic_change_percent": -11.1,
  "paid_traffic": 192150,
  "total_search_traffic": 5156055,
  "backlinks": 141005083,
  "backlinks_change_percent": -3.87,
  "referring_domains": 732469,
  "google_penalty_risk": "Low",
  "top_country": "US",
  "top_country_traffic": 59382926,
  "top_countries": [{ "country": "US", "country_name": "United States", "visits": 59382926, "share_percent": 25.54, "desktop_share_percent": 37.37, "mobile_share_percent": 62.63 }],
  "keywords_database": "US",
  "top_keywords": [{ "keyword": "stripe login", "position": 1, "search_volume": 135000, "cpc": 14.46, "traffic_percent": 7.08, "intents": [] }],
  "competitors": [{ "domain": "gocardless.com", "relevance": 0.14, "visits": 3032397 }],
  "traffic_sources": [{ "source": "Direct", "source_type": "Direct", "visits": 54586835, "previous_visits": 46022598, "share_percent": 43.49 }],
  "ai_traffic": [{ "source": "chatgpt.com", "name": "ChatGPT", "visits": 1268580, "share_percent": 0.7 }],
  "search_traffic_history": [{ "month": "2026-09", "organic": 4963905, "paid": 192150, "total": 5156055 }],
  "competitor_count": 3
}
```

A competitor row and a top-websites row (same run):

```json
{ "type": "competitor", "competitor_of": "stripe.com", "position": 1, "domain": "gocardless.com", "relevance": 0.14,
  "authority_score": 58, "visits": 3032397, "visits_change_percent": 16.98, "global_rank": 19485, "global_rank_change_places": 1656,
  "country_rank": 954, "country_rank_country": "GB", "category_rank_name": "Accounting and Auditing",
  "bounce_rate_percent": 44.72, "pages_per_visit": 4.1327, "time_on_site_seconds": 303, "data_month": "2026-09" }
{ "type": "top_website", "ranking_country_name": "World", "ranking_industry_name": "All Industries", "rank": 1, "domain": "google.com",
  "visits": 108899227055, "desktop_share_percent": 35.85, "mobile_share_percent": 64.15,
  "visits_change_mom_percent": 3, "visits_change_yoy_percent": 1.62, "top_traffic_source": "direct", "data_month": "2026-09" }
```

#### Fields

Fill measured on 2026-10-28: 75 websites from a 99-domain buyer list (24 had no public Semrush page), 1,000 websites from Semrush's own list (mostly small sites), 162 competitor rows of 30 domains, 1,000 top-websites rows of 10 countries:

| Field | Buyer list | Small sites | Meaning |
|---|---:|---:|---|
| `authority_score`, `backlinks`, `referring_domains`, `google_penalty_risk` | 100% | 99.6% | authority and links |
| `visits`, engagement, `top_countries`, `global_rank` | 100% | 86.5% | traffic and ranks |
| `organic_traffic`, `paid_traffic`, `search_traffic_history` | 100% | 65.2% | search traffic |
| `top_keywords` | 100% | 45.5% | 5 keywords |
| `competitors` | 94.7% | 37.8% | closest competitors |
| `categories`, `category_rank` | 94.7%, 80% | 39.1%, 0.9% | industries |
| `ai_traffic` | 97.3% | 22.9% | AI sources |
| `brand_name` | 62.7% | 0.1% | only well-known brands |
| `description`, `*_rank_change_places` (with `includeCompetitors`) | 100% on 30 of 30 | | from the competitors page |
| competitor rows: Authority Score, visits, ranks, engagement / `relevance` | 100% / 54.9% | | relevance only for the competitors the website page shows |
| top-websites rows: every field / `visits_change_yoy_percent` | 100% / 96.8% | | |

`type` tells the three row kinds apart; columns that do not apply to a row are absent or `null`. Percent fields are percent (61.53 = 61.53%).

### Use cases

- 🧲 **Lead scoring**: add visits, Authority Score, industry and main country to a CRM list of company domains.
- 📊 **Competitor benchmarking**: line up competitors' traffic, engagement, ranks and backlinks month by month.
- 🔗 **Link building**: score outreach lists by Authority Score, referring domains and penalty risk.
- 💼 **Domain and website due diligence**: traffic, channels and history before you buy or invest.
- 🗺️ **Market maps**: the 100 most visited websites of a country and industry, with full data per site.
- 🤖 **AI traffic reporting**: see how much ChatGPT, Claude and other AI sites send to each website.

### How much does it cost to scrape Semrush?

Pay per row, no start fee:

| Event | Price |
|---|---|
| Website row | **$0.0009** ($0.90 per 1,000) |
| Top-websites row | $0.0009 |
| Competitor row | $0.0013 |

| Run | Rows | Price |
|---|---|---|
| 100 websites | 100 | $0.09 |
| 30 websites + their competitors | 30 + 162 | $0.24 |
| Top 100 of 10 countries | 1,000 | $0.90 |
| 1,000 websites | 1,000 | $0.90 |

A domain without a public Semrush page, a filtered row and an unchanged monitor row cost nothing. Cap any run with **Maximum cost per run**; it stops at the cap and says so.

### Integrations, API, scheduling & MCP

- **Schedule** it monthly (Semrush refreshes these pages once a month) with **Monitor mode** on, and only changed websites come back, with `change_since_last_run`.
- **Webhooks** send the finished dataset to your app; connect **Make, Zapier, n8n, Google Sheets** or **Slack** from the Integrations tab.
- **API**: run it from [Python](https://apify.com/topapi/semrush-scraper/api/python) or [JavaScript](https://apify.com/topapi/semrush-scraper/api/javascript) with `apify-client`, or call the REST endpoint.
- **MCP**: add it to Claude, Cursor or any MCP client through the [Apify MCP server](https://apify.com/topapi/semrush-scraper/api/mcp).

### More SEO and website scrapers

- [Ahrefs Scraper](https://apify.com/topapi/ahrefs-seo-scraper) - Domain Rating, organic traffic, top websites and AI visibility from Ahrefs.
- [SimilarWeb Scraper](https://apify.com/topapi/similarweb-scraper) - total website traffic, rank and competitors from SimilarWeb.
- [Website Technology Scraper](https://apify.com/topapi/website-technology-scraper) - tech stack, CMS and analytics of a website.

More from [TopApi](https://apify.com/topapi).

### Limits & empty runs

- **Coverage**: Semrush publishes a public page for about 250,000 websites. On a 99-domain buyer list 75 had one; some well-known sites have none (zapier.com, mazda.de on 2026-10-28). Those come back in the run summary, free.
- **Not in the rows**: keyword research for your own keywords (volume, keyword difficulty, ideas, SERP features), full organic keyword and backlink lists, keyword counts, traffic cost and AI visibility scores. Semrush shows those only to signed-in users or behind a reCAPTCHA check on its free tools.
- **Rank changes in places** are on competitor rows and on website rows with `includeCompetitors`; every website row has `*_rank_trend` (up / down / same).
- **Estimates**: every figure is Semrush's monthly estimate for `data_month`; Semrush updates the pages once a month.
- **Empty runs** say why in the status message and in `RUN_SUMMARY` (not published, filtered out, unchanged since the last run, or not reachable). If Semrush refuses every request on every route, the run ends FAILED and nothing is charged.

# Actor input Schema

## `domains` (type: `array`):

Websites to look up, one per line: a domain (stripe.com), any URL on it (https://www.stripe.com/pricing) or a Semrush page (semrush.com/website/stripe.com/overview/, semrush.com/website/stripe.com/competitors/ for competitor rows, or a top-websites page such as semrush.com/trending-websites/us/finance). www., case and paths are normalised; a subdomain Semrush does not publish falls back to its parent domain. A domain without a public Semrush page is listed in the run summary and never charged.

## `urlsFromFile` (type: `string`):

Paste a list (one domain or URL per line, a CSV whose first domain-looking cell per line is used, or a JSON array), or give a direct public download link to such a file (.csv / .json / .txt, up to 2 MiB).

## `allTrackedDomains` (type: `boolean`):

Read the full list of websites Semrush publishes a public page for (about 250,000, from its sitemaps) and deliver a website row for each, up to Max rows. Combine with Domain endings, Exclude domains containing and the filters.

## `domainSuffixes` (type: `array`):

Keep only domains ending with one of these (.de, .co.uk, .fr). Applied before any page is read, at no cost.

## `excludeKeywords` (type: `array`):

Skip any domain whose name contains one of these words (case ignored), e.g. casino. Applied before any page is read, at no cost.

## `includeCompetitors` (type: `boolean`):

Read each website's Semrush competitors page too and deliver one competitor row per competing website (Authority Score, visits and change, global / country / industry rank and their change in places, bounce rate, pages per visit, time on site). Charged per competitor row. The website row also gets its own rank changes in places and Semrush's description.

## `competitorsOnly` (type: `boolean`):

Deliver only the competitor rows of each domain, without its website row.

## `maxCompetitorsPerDomain` (type: `integer`):

Competitor rows taken from each competitors page (Semrush lists 1-10, most often 3-7).

## `includeHistory` (type: `boolean`):

Add the series Semrush publishes to each website row: visits (3 months), desktop / mobile visits, organic / paid search traffic, backlinks and referring domains (6 months each), and each AI source (6 months). Free.

## `includeTopCountries` (type: `boolean`):

Add the top 5 countries by visits (visits, share, desktop / mobile share). Free.

## `includeTopKeywords` (type: `boolean`):

Add the top 5 organic keywords (position, search volume, CPC, traffic share, intent). Free.

## `includeTrafficSources` (type: `boolean`):

Add where visitors come from (direct, search, referring websites) and where they go next, with visits and share. Free.

## `includeAiTraffic` (type: `boolean`):

Add the visits each AI assistant and AI website sends (ChatGPT, Claude, Grok, ...), with share and history. Free.

## `locations` (type: `array`):

Top-websites rankings to read: the 100 most visited websites of each country (World = global). Every country is read for every industry below. Leave empty to skip rankings.

## `topWebsitesCategories` (type: `array`):

Industries of the rankings (empty = all industries).

## `topWebsitesLimit` (type: `integer`):

Rows taken from each ranking (Semrush publishes 100).

## `enrichTopWebsites` (type: `boolean`):

Read each ranked website's own Semrush page too and add its full website data to the ranking row (charged as one top-website + one website event).

## `minAuthorityScore` (type: `integer`):

Keep only websites with at least this Authority Score. Every filter runs before the charge.

## `maxAuthorityScore` (type: `integer`):

Keep only websites with at most this Authority Score.

## `minVisits` (type: `integer`):

Keep only websites with at least this many monthly visits.

## `maxVisits` (type: `integer`):

Keep only websites with at most this many monthly visits.

## `minOrganicTraffic` (type: `integer`):

Keep only websites with at least this much monthly organic search traffic (website rows).

## `onlyCategories` (type: `array`):

Keep only websites Semrush files under one of these industries (any of the website's categories, or a competitor's ranking industry).

## `onlyCountries` (type: `array`):

Keep only websites whose main country (where most visits come from, by Semrush) is one of these two-letter codes, e.g. US, GB, DE.

## `monitorMode` (type: `boolean`):

Only deliver (and charge) what is new or changed since the last run with the same monitor name: a website or competitor when Semrush's data month, visits, Authority Score, organic traffic, backlinks, referring domains or global rank changed (with the changes since the last run), a top-websites row when it is new to the ranking or moved.

## `monitorOutput` (type: `string`):

What a monitor run delivers.

## `monitorStoreName` (type: `string`):

Named key-value store holding what earlier runs delivered. Give each schedule its own name.

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

Rows for the whole run, all kinds together (0 = no limit).

## `maxConcurrency` (type: `integer`):

Pages read in parallel.

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

Optional. By default the actor reads directly and climbs to Apify datacenter, then residential, only when a route is refused. Set your own proxy to use it first.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "github.com",
    "wikipedia.org"
  ],
  "allTrackedDomains": false,
  "includeCompetitors": false,
  "competitorsOnly": false,
  "maxCompetitorsPerDomain": 20,
  "includeHistory": true,
  "includeTopCountries": true,
  "includeTopKeywords": true,
  "includeTrafficSources": true,
  "includeAiTraffic": true,
  "locations": [
    "global"
  ],
  "topWebsitesLimit": 10,
  "enrichTopWebsites": false,
  "monitorMode": false,
  "monitorOutput": "changes",
  "monitorStoreName": "semrush-monitor",
  "maxItems": 300,
  "maxConcurrency": 8
}
```

# Actor output Schema

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

One item per website, competitor or top-websites ranking row (the type field says which).

# 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 = {
    "domains": [
        "stripe.com",
        "github.com",
        "wikipedia.org"
    ],
    "locations": [
        "global"
    ],
    "topWebsitesLimit": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/semrush-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 = {
    "domains": [
        "stripe.com",
        "github.com",
        "wikipedia.org",
    ],
    "locations": ["global"],
    "topWebsitesLimit": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("topapi/semrush-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 '{
  "domains": [
    "stripe.com",
    "github.com",
    "wikipedia.org"
  ],
  "locations": [
    "global"
  ],
  "topWebsitesLimit": 10
}' |
apify call topapi/semrush-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,topapi/semrush-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/tStXMZWr7gtUb1c5B/builds/JhLFmU2T597Qetnr1/openapi.json