# Mobile.bg Scraper - Bulgarian Car Marketplace (`studio-amba/mobile-bg-scraper`) Actor

Scrape car listings from Mobile.bg, Bulgaria's largest vehicle marketplace with 3M+ monthly visits. Extract prices, specs, mileage, fuel type, transmission, power, seller info, and images. Filter by make, model, year, price range. No login required.

- **URL**: https://apify.com/studio-amba/mobile-bg-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 10 total users, 3 monthly users, 98.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 result scrapeds

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 Mobile.bg Scraper do?

**Mobile.bg Scraper** extracts car listing data from [Mobile.bg](https://www.mobile.bg), Bulgaria's largest online vehicle marketplace with over **3 million monthly visits** and hundreds of thousands of active listings. No login or cookies required.

Use it to collect structured used car data via the Apify platform with full **API access, scheduling, integrations**, and proxy rotation.

### Why use Mobile.bg Scraper?

- **Market research** — Analyze Bulgarian used car prices, compare by make, model, year, and mileage
- **Price monitoring** — Track price changes for specific vehicles over time with scheduled runs
- **Dealer intelligence** — Study dealer inventory, pricing strategies, and listing volumes
- **Data analytics** — Build datasets for automotive market analysis in Southeast Europe
- **Lead generation** — Find cars matching specific criteria across Bulgaria
- **Academic research** — Study depreciation curves, pricing patterns, and market trends
- **Cross-border arbitrage** — Compare Bulgarian car prices with other European markets (typically 20-40% lower than Western Europe)

### How to scrape Mobile.bg data

1. Go to this actor's page on the [Apify Store](https://apify.com/store).
2. Click **Try for free** to open it in Apify Console.
3. Configure your search: enter a make (e.g., "BMW"), model, year range, or price range.
4. Set the maximum number of results you need (default: 100).
5. Click **Start** and wait for the run to finish.
6. Download your data from the **Output** tab in JSON, CSV, Excel, or other formats.

You can also schedule regular runs, set up webhooks for real-time notifications, or integrate the results directly into your application using the [Apify API](https://docs.apify.com/api).

### Input

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | Free text search (e.g., "BMW", "Audi A4", "Golf"). Defaults to "BMW" if no filters set. |
| `make` | string | Car manufacturer slug (e.g., bmw, audi, mercedes-benz, volkswagen, opel, toyota) |
| `model` | string | Car model as used in Mobile.bg URLs (e.g., 3-seriya, golf, a4) |
| `yearFrom` / `yearTo` | integer | Registration year range (e.g., 2015-2024) |
| `priceFrom` / `priceTo` | integer | Price range in EUR |
| `mileageMax` | integer | Maximum mileage in km |
| `mileageMin` | integer | Minimum mileage in km. Mobile.bg has no such filter, so the actor drops listings below it after reading the results. |
| `fuelType` | string | benzin (Petrol), dizel (Diesel), gaz (LPG/CNG), elektro (Electric), hibrid (Hybrid), plug-in-hibrid (Plug-in Hybrid), vodorod (Hydrogen). An unknown value stops the run and lists the valid ones. |
| `transmission` | string | manual, automatic, semi-automatic. Uses Mobile.bg's own gearbox filter. Empty = any. |
| `powerFrom`, `powerTo` | integer | Engine power in hp. Uses Mobile.bg's own power filter. |
| `equipment` | array | Only cars with all the listed options, e.g. `["navigation", "leather-interior"]`. Uses Mobile.bg's own equipment filter, which relies on what the seller ticked. An unknown value stops the run and lists the valid ones. |
| `sellerType` | string | any (default), dealer, private. Uses Mobile.bg's own seller filter. |
| `maxResults` | integer | Max listings to return (default: 100, max: 5000) |
| `fetchDetails` | boolean | Off by default. Opens every ad page and adds views, editedAt, photosCount, vin, productionDate, description, dealerName, dealerUrl. Without it those fields are not in the output. |
| `trackListings` | boolean | Off by default. Remembers the listings of this search between runs and adds status, firstSeenAt, lastSeenAt, removals and a segment summary with market days supply. See below. |
| `trackingKey` | string | Name of the tracked segment. Empty = derived from the search filters. |
| `salesWindowDays` | integer | Days counted as potential sales for market days supply (default 45). |
| `priceBands` | array | Band edges for the price breakdown in the summary (default 5000, 10000, 15000, 20000, 30000, 50000). |
| `wholeMarket` | boolean | Off by default. Reads every car listing on Mobile.bg with `trackListings` on, one search per make and year range. See below. |
| `wholeMarketConcurrency` | integer | Searches at a time in whole-market mode (default 6, each uses 4 GB). |
| `wholeMarketMaxUsageUsd` | number | Optional platform usage cap for a whole-market read. |
| `wholeMarketMakes` | array | Optional make slugs to limit a whole-market read (e.g. `bmw`, `vw`). |
| `proxyConfiguration` | object | Proxy settings — residential proxies recommended |

### Output

Each car listing includes the following fields. You can download the dataset in JSON, CSV, Excel, or connect via API.

```json
{
    "listingTitle": "BMW 435 F36 N55 X-Drive ЛИЗИНГ * FULL",
    "make": "BMW",
    "model": "435 F36 N55 X-Drive ЛИЗИНГ * FULL",
    "year": 2016,
    "price": 18000,
    "priceOnRequest": false,
    "currency": "EUR",
    "mileage": 205200,
    "fuelType": "Petrol",
    "transmission": "Automatic",
    "engineSize": "3000 cc",
    "power": "400 hp",
    "location": "обл. Русе, гр. Русе",
    "sellerType": "Private",
    "imageUrl": "https://mobistatic1.focus.bg/mobile/photosorg/646/1/11780325899651646_W5.webp",
    "url": "https://www.mobile.bg/obiava-11780325899651646-bmw-435-f36-n55-x-drive-lizing-full",
    "listingId": "11780325899651646",
    "listedAt": "2026-06-01T14:58:19.000Z",
    "scrapedAt": "2026-09-19T15:13:17.691Z"
}
```

### Data fields

| Field | Description | Example |
|-------|-------------|---------|
| `listingTitle` | Full listing title | BMW 320 2.0d Sport |
| `make` | Manufacturer | BMW, Audi, Mercedes-Benz |
| `model` | Model name. When the search pins a model or series, this is that model as the title spells it, so every row of the search groups under one value. | 320, Golf, A4, 3008 |
| `modelDetail` | Listing title after the make, as the seller wrote it (model, engine, trim) | 3008 1.5HDI TOP LED |
| `year` | Registration year | 2018 |
| `price` | Listing price (numeric, may have cents). `null` when the seller shows "Запитване" (price on request) | 18000 |
| `priceOnRequest` | `true` when the listing shows "Запитване" instead of a price | false |
| `currency` | Price currency | EUR or BGN |
| `mileage` | Kilometers driven | 155000 |
| `fuelType` | Fuel type | Petrol, Diesel, LPG/CNG, Electric, Hybrid, Plug-in Hybrid |
| `transmission` | Gearbox type | Manual, Automatic, Semi-automatic |
| `engineSize` | Engine displacement. Empty when the listing does not state it | 2000 cc |
| `power` | Engine power | 190 hp |
| `location` | Seller location as shown on Mobile.bg | обл. Русе, гр. Русе |
| `sellerType` | Seller category | Private or Dealer |
| `imageUrl` | Main car photo URL | https://mobistatic1.focus.bg/mobile/photosorg/... |
| `url` | Full listing URL | https://www.mobile.bg/obiava-... |
| `listingId` | Mobile.bg ad id (17 digits) | 11780325899651646 |
| `listedAt` | When the ad was created. Decoded from the ad id: digits 2 to 11 are a unix timestamp. Mobile.bg does not print this date; a renewed ad keeps its id and its date. | 2026-06-01T14:58:19.000Z |
| `scrapedAt` | Collection timestamp | 2026-06-09T12:00:00.000Z |

With `fetchDetails` on, each row also has:

| Field | Description |
|-------|-------------|
| `views` | View count shown on the ad |
| `editedAt` | Last edit time, or the publication time if the ad was never edited (UTC) |
| `photosCount` | Number of photos |
| `vin` | VIN, only when the seller entered one (many don't) |
| `productionDate` | Production month as YYYY-MM |
| `description` | Seller's description text |
| `dealerName`, `dealerUrl` | Dealer name and dealer page. Null for private sellers. |
| `detailsError` | Set when the ad page could not be read; the other detail fields are then null |

### Track listings and market days supply

Turn on `trackListings` and run the same search every day. The actor remembers each listing of the search in a key-value store called `mobile-bg-tracking` in your own Apify account, under one key per search (`trackingKey`).

Every run then outputs:

- One row per active listing with `status` (`new` or `active`), `firstSeenAt`, `lastSeenAt`, `previousPrice`, `priceChanged` and `daysListed`.
- One row with `status: "removed"` for each listing that disappeared since the last run. `removalClass` is `reposted` when a new ad for the same car showed up in the same run (same VIN, or same make, model, year, fuel, gearbox, seller type and location with mileage within 2% or 1500 km), otherwise `potential_sold`.
- One row with `status: "active_outside_filter"` for a listing that is still online but no longer matches your filters, for example after a price change. It is not counted as a removal.
- One row with `recordType: "__SEGMENT_SUMMARY__"` with the segment numbers: active listings, potential sales and reposts in the sales window, average daily sales, `mdsDays`, median, 25th and 75th percentile (`p25Price`, `p75Price`), average, min and max price, and a count per price band.

Market days supply is calculated as:

```
mdsDays = activeListings / (potentialSalesInWindow / effectiveWindowDays)
```

`effectiveWindowDays` is `salesWindowDays` (45 by default), or the number of days tracked so far when that is shorter. The summary says so in `notes` until the window is full. `mdsDays` is null when there were no potential sales in the window.

#### Limitations

- **Mobile.bg does not say why an ad disappeared.** A removed ad and an id that never existed return the same page ("the ad was deleted or is not active"). So a removal is a potential sale, never a confirmed one. Every removal row carries `removalConfidence: "site does not say why an ad disappeared"`. Expect some removals to be sellers who gave up or moved the car to another site.
- **A listing is only marked removed when the run read every result page.** The actor compares what it read with the count Mobile.bg shows ("от общо N"). If `maxResults` stopped the run early, or a page could not be read, nothing is marked removed and the summary explains why in `incompleteReason`. Set `maxResults` above the size of your search.
- **Missing listings are checked one by one.** Before a listing counts as removed, the actor opens its ad page. Listings move between result pages while a run reads them, so this stops a listing that was only skipped from counting as a sale.
- **The first run is the baseline.** Removals and sales are counted from the second run on.
- **Reposts are matched within one run.** A car that comes back days later under a new id counts as a new listing.
- **Run one schedule per search.** Two runs on the same `trackingKey` at the same time overwrite each other's state.

#### How to schedule it daily on Apify

1. Fill in your search and turn on `trackListings`. Set `maxResults` above the number of listings Mobile.bg shows for that search.
2. Save it as a task in Apify Console.
3. Open **Schedules**, create a schedule with a daily time (for example 06:00), and add the task.
4. Read the `__SEGMENT_SUMMARY__` row of each run, or the full dataset for listing-level history.

To track several segments (for example price bands or model years), make one task per segment. Each gets its own `trackingKey`.

#### Whole-market read

Turn on `wholeMarket` to read every car listing on Mobile.bg in one run, for example once a week for market days supply across the whole Bulgarian market.

- Mobile.bg shows at most 3,000 listings per search, so the actor reads one search per make, and the biggest makes (BMW, Mercedes-Benz, Audi, VW and others) per year range. That is about 190 searches and about 140,000 listings.
- Each search runs as its own run of this actor in your account, with `trackListings` on and its own segment key `<trackingKey>-<make>-<from>-<to>` (x = open end). Keep the same `trackingKey` every week so each segment continues its history.
- The listings are in each search run's dataset. The whole-market run's own dataset has one `__WHOLE_MARKET_SEGMENT__` row per search with the run id, dataset id, listings, removals and mdsDays. `MARKET_READ_SUMMARY` in the run's key-value store has the totals.
- A search that fails or comes up short is read again (up to 3 times). A search that has grown past 3,000 listings is split by year and starts a new segment.
- Search and filter fields are ignored in this mode. A read takes about 2 hours at 6 searches at a time.

### How much does it cost to scrape Mobile.bg?

Mobile.bg Scraper uses Playwright (headless browser) for reliable access. It charges $0.02 per run (start fee, based on its 4 GB memory allocation) plus $0.002 per result. 50 results costs about $0.12; 100 about $0.22; 500 about $1.02. A run's usage cost only settles after it reports SUCCEEDED.

Every dataset row is a result. With `trackListings` on, the removal rows and the one summary row per run are results too, so a daily run on a 200-listing segment costs about $0.02 + 200 to 210 results x $0.002, roughly $0.43. A whole-market read is about 140,000 listings plus the removal rows, billed at the same price per result. `fetchDetails` does not change the price per result, but the run takes longer because it opens every ad page.

### Tips and advanced options

- **Use make for precision** — Set the `make` field (e.g., "bmw") for targeted results instead of free text search.
- **Combine filters** — Year range, price range, maximum mileage and fuel type are passed to Mobile.bg's own search filters, so they combine the same way they do on the site.
- **Bulgarian URL slugs** — Model names use Bulgarian transliteration in URLs (e.g., "3-seriya" for 3 Series).
- **Schedule runs** — Set up daily or weekly scraping to track price changes over time.
- **Empty input works** — Running with empty input `{}` defaults to searching for "BMW" to ensure results are returned.
- **Use residential proxies** — For best reliability, use Apify residential proxies (pre-configured by default).
- **Cross-market analysis** — Combine with our AutoScout24, Polovni Automobili, or LaCentrale scrapers to compare prices across European markets.
- **Prices in EUR** — Bulgaria moved to the euro in 2026 and Mobile.bg shows prices in EUR. Older listings can still show BGN; the currency field tells you which.

### Supported vehicle categories

Mobile.bg covers passenger cars and SUVs as the primary categories. The scraper focuses on the main vehicle listings which include:

- All major European and Asian car manufacturers
- Both private sellers and professional dealers
- New and used vehicles
- Prices in EUR and BGN (Bulgarian Lev, 1 EUR = ~1.96 BGN)

### About Mobile.bg

Mobile.bg is Bulgaria's dominant online vehicle marketplace, operating since 2000. It is the go-to platform for buying and selling cars in Bulgaria, with over 3 million monthly visits. The site features listings from both private sellers and professional dealers across all of Bulgaria. Prices are typically listed in EUR, with BGN conversions shown alongside.

Bulgaria is a popular destination for used car sourcing due to competitive pricing compared to Western European markets.

### FAQ and support

**Is it legal to scrape Mobile.bg?**
This scraper accesses only publicly available data that any visitor can see in their browser. It does not require login, bypass authentication, or access private data. Always review and comply with the target website's Terms of Service before use.

**Does this scraper need login or cookies?**
No. Mobile.bg Scraper works without any login credentials, cookies, or account setup. Just configure your search filters and run.

**What about anti-bot protection?**
The scraper uses Playwright (headless browser) with residential proxies to reliably access listing pages. This handles standard anti-bot measures without any extra configuration.

**Can I scrape specific makes and models?**
Yes. Use the `make` field with the manufacturer name (e.g., "bmw", "audi", "volkswagen") and optionally the `model` field for further filtering.

**Can I search a whole line, like "BMW 3 Series" or "Mercedes C-Class"?**
Yes. Mobile.bg itself has no single listing page for a series or class — each
trim (320, 325, c-200, c-220, ...) has its own page — so a "3 Series" or
"C-Class" query is expanded internally to every trim in that line and the
results are merged. This currently covers BMW 1-7 Series and Mercedes A/B/C/E/S-Class;
a specific trim (e.g. "320", "c-220") always works and is the more precise option.

**What about character encoding?**
Mobile.bg uses Cyrillic text (Bulgarian language). The scraper handles encoding automatically and outputs normalized UTF-8 data with translated field values (e.g., fuel types are translated to English).

**I found a bug or need help**
Please submit an issue on the [Issues tab](https://console.apify.com/actors) and we will respond quickly. For custom scraping solutions, reach out via the same channel.

# Actor input Schema

## `searchQuery` (type: `string`):

Free text search for car listings (e.g., 'BMW', 'Audi A4', 'Golf'). Leave empty to browse all listings with other filters.

## `make` (type: `string`):

Car manufacturer as used on Mobile.bg (e.g., bmw, audi, mercedes-benz, volkswagen, opel, toyota, renault, peugeot, ford, honda).

## `model` (type: `string`):

Car model as used on Mobile.bg (e.g., 3-seriya, golf, a4, clio). Use Bulgarian transliteration as shown in URLs.

## `yearFrom` (type: `integer`):

Minimum registration year (e.g., 2015).

## `yearTo` (type: `integer`):

Maximum registration year (e.g., 2024).

## `priceFrom` (type: `integer`):

Minimum price in EUR.

## `priceTo` (type: `integer`):

Maximum price in EUR.

## `mileageMax` (type: `integer`):

Maximum mileage in kilometers.

## `mileageMin` (type: `integer`):

Minimum mileage in kilometers. Mobile.bg has no minimum-mileage filter, so the actor reads the results and drops listings below this value.

## `fuelType` (type: `string`):

Filter by fuel type, using Mobile.bg's own fuel filter.

## `transmission` (type: `string`):

Filter by gearbox, using Mobile.bg's own transmission filter. Leave empty for any.

## `powerFrom` (type: `integer`):

Minimum engine power in horsepower, using Mobile.bg's own power filter.

## `powerTo` (type: `integer`):

Maximum engine power in horsepower, using Mobile.bg's own power filter.

## `equipment` (type: `array`):

Only cars with ALL the selected options, using Mobile.bg's own equipment filter. It relies on what the seller ticked in the ad, so a car with the option but no tick is not returned. Each extra option usually lowers the number of cars.

## `sellerType` (type: `string`):

Uses Mobile.bg's own seller filter (registered dealers or private sellers).

## `maxResults` (type: `integer`):

Maximum number of car listings to return.

## `fetchDetails` (type: `boolean`):

Off by default. When on, the actor opens every ad page and adds views, editedAt (last edit, or publication time if never edited), photosCount, vin, productionDate, description, dealerName and dealerUrl. Without it those fields are not in the output at all. One extra page per listing, so runs take longer. VIN is only there when the seller entered it.

## `trackListings` (type: `boolean`):

Off by default. When on, the actor remembers every listing of this search in a key-value store in your account ("mobile-bg-tracking") and adds firstSeenAt, lastSeenAt, status (new, active), price changes, one row per listing that disappeared since the last run (status removed, with removalClass potential_sold or reposted), and one **SEGMENT_SUMMARY** row with market days supply. Mobile.bg does not say why an ad disappeared, so a removal is a potential sale, never a confirmed one. Set maxResults above the number of listings in the search: listings are only marked removed when the run read every result page. Schedule the same input daily.

## `trackingKey` (type: `string`):

Name of the tracked segment in the store. Leave empty to derive it from the search filters, so the same filters always continue the same history. Set your own for a readable name (letters, digits, - \_ . only). A new key starts a new history.

## `salesWindowDays` (type: `integer`):

Number of past days counted as potential sales for the market days supply: MDS = active listings / (potential sales in the window / window days).

## `priceBands` (type: `array`):

Band edges for the price breakdown in the segment summary, in the listing currency (EUR). Default \[5000, 10000, 15000, 20000, 30000, 50000] gives 0-4999, 5000-9999, ... and 50000+.

## `wholeMarket` (type: `boolean`):

Off by default. When on, the actor reads every car listing on Mobile.bg with trackListings on, and ignores the search and filter fields. Mobile.bg shows at most 3,000 listings per search, so the market is read as one search per make, and per year range for the big makes (about 190 searches, about 140,000 listings). Each search runs as its own run of this actor in your account and keeps its own tracked segment "<trackingKey>-<make>-<from>-<to>" (x = open end). The listings are in each search's run dataset; this run's dataset has one row per search (run id, dataset id, listings, removed, mdsDays) and the run store has MARKET_READ_SUMMARY. A search that has grown past 3,000 listings is split by year and starts a new segment. You pay the normal per-result price for every listing read, so a whole-market read is about 140,000 results.

## `wholeMarketConcurrency` (type: `integer`):

How many searches run at the same time in whole-market mode. Each search run uses 4 GB of memory, so 6 needs 24 GB free in your account. More than 6 caused page timeouts in our tests.

## `wholeMarketMaxUsageUsd` (type: `number`):

Optional hard cap for whole-market mode. No new search is started once the finished search runs plus the running ones would pass this amount of platform usage. Searches not started are listed in MARKET_READ_SUMMARY.

## `wholeMarketMakes` (type: `array`):

Optional. Mobile.bg make slugs as in the site's URLs (e.g. "bmw", "mercedes-benz", "vw"). Empty = every make on the site.

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

Proxy settings. Residential proxies recommended for reliable access to Mobile.bg.

## Actor input object example

```json
{
  "searchQuery": "BMW",
  "sellerType": "any",
  "maxResults": 5,
  "fetchDetails": false,
  "trackListings": false,
  "salesWindowDays": 45,
  "wholeMarket": false,
  "wholeMarketConcurrency": 6,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchQuery": "BMW",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/mobile-bg-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 = {
    "searchQuery": "BMW",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/mobile-bg-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 '{
  "searchQuery": "BMW",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/mobile-bg-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/mobile-bg-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/f55f5aUrfIuCxJ4aJ/builds/hALWniLqefDyA1IIs/openapi.json