# SS.LV Latvia Classifieds Scraper (`solidcode/ss-lv-scraper`) Actor

\[💰 $3 / 1K] Extract classified ads from SS.LV / SS.COM, Latvia's biggest marketplace — real estate, cars, jobs, electronics and more. Get price, price/m², location, photos, descriptions and per-category specs. Paste any SS.LV URL or search by keyword, in English, Latvian or Russian.

- **URL**: https://apify.com/solidcode/ss-lv-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Automation, Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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.
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

## SS.LV Latvia Classifieds Scraper

Pull classified ads from SS.LV — Latvia's dominant marketplace — across every section: real estate, cars and transport, jobs, electronics, home goods, animals and services. Every ad comes back with its title, price and price-per-m², map coordinates, full photo gallery, per-category specifications and its own SS.LV id, in English, Latvian or Russian. Built for property analysts, car dealers, market researchers and lead-generation teams who need clean, structured Latvian classifieds data without copying ads out of SS.LV's tables one page at a time.

### Why This Scraper?

- **All dozen-plus SS.LV sections, not just real estate** — real estate, transport, jobs, electronics, construction, home goods, animals, agriculture, children, clothing, and services all flow through one actor with the same clean output shape.
- **Three interface languages from one setting** — request English, Latvian, or Russian results and get correctly rendered Cyrillic and Latvian-diacritic text (Рига, Pārdod, Sērija, Комнат) with no mojibake.
- **Map coordinates on every mapped ad** — real latitude and longitude pulled straight from each listing's map pin, ready to plot on a map or filter by radius.
- **Per-category specifications captured automatically** — a car ad returns make, year, mileage and gearbox; a flat returns rooms, area, floor and building series — all in one structured `attributes` map, with no per-category setup.
- **Price and price-per-m² parsed for you** — a numeric `price`, its currency, the exact price string as shown on the site, and the €/m² figure wherever SS.LV publishes it.
- **Keyword search across the whole marketplace** — type "audi" or "iphone" and search all of SS.LV at once, or paste several category, filtered-search, or single-ad URLs in one run (the competitor takes exactly one URL and no keywords).
- **A stable SS.LV ad id on every row** — dedupe cleanly across repeat runs and follow the same ad over time.
- **Full-detail mode on demand** — flip one switch to add the complete description, the full photo gallery, map coordinates, the listing date, and every seller-filled specification.
- **A built-in result cap** — set a maximum and the run stops itself at the next page boundary, so a broad category never runs up an open-ended bill.

### Use Cases

**Real Estate Research**
- Track flat and house prices and price-per-m² by city, district and street across Latvia
- Map listings by their coordinates to study a neighbourhood or catchment area
- Compare building series and house types within a district
- Monitor new listings in Riga Centre and other hot areas over time

**Automotive & Vehicle Market**
- Build a live catalogue of cars by make and model with year, mileage and gearbox
- Benchmark asking prices for a specific model across the whole country
- Spot newly listed vehicles for dealer sourcing and trade-in valuation
- Watch trucks, trailers, motorcycles and parts alongside passenger cars

**Price Monitoring & Reselling**
- Track electronics, phones and home-goods prices for arbitrage and resale
- Follow a keyword ("iphone", "playstation") across every section at once
- Detect underpriced listings the moment they appear
- Compare the same item across categories and languages

**Lead Generation & Market Entry**
- Map who is advertising services, jobs and businesses in a region
- Size a category by pulling its full inventory with a single result cap
- Assemble structured datasets of sellers and their listings for outreach
- Localise research in English, Latvian or Russian to match your team

**Data Enrichment & Integration**
- Enrich an existing property or vehicle database with fresh SS.LV pricing
- Feed classifieds data into dashboards, alerts and comparison tools
- Power market reports with per-category specifications and coordinates
- Schedule recurring runs to keep a downstream dataset current

### Getting Started

#### Scrape a Category Page

The simplest run — paste any SS.LV category or filtered-search URL:

```json
{
    "startUrls": ["https://www.ss.lv/en/real-estate/flats/riga/centre/sell/"],
    "maxResults": 50
}
````

#### Search by Keyword

Skip the URL and just say what you're looking for:

```json
{
    "searchQueries": ["audi", "iphone"],
    "language": "en",
    "maxResults": 100
}
```

#### Full Details, Multiple Sources, Latvian

Mix category URLs and keywords, switch the output language, and turn on full detail enrichment for descriptions, galleries, coordinates and specs:

```json
{
    "startUrls": [
        "https://www.ss.lv/en/transport/cars/audi/",
        "https://www.ss.lv/en/real-estate/flats/riga/centre/sell/"
    ],
    "searchQueries": ["dzīvoklis Rīgā"],
    "language": "lv",
    "includeDetails": true,
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `["https://www.ss.lv/en/real-estate/flats/riga/centre/sell/"]` | One or more SS.LV category pages, filtered-search pages, or individual ad pages. The easiest way: set your filters on ss.lv, then copy the address from your browser's address bar. Every page of results is followed automatically. |
| `searchQueries` | string\[] | `[]` | Keywords to search across the whole of SS.LV, for example "audi", "dzīvoklis Rīgā", or "iphone". Every page of results is collected. |
| `language` | select | `English` | Which language version of SS.LV to read — English, Latvian, or Russian. This changes the wording of labels and categories; the ads are the same in all three. Any URL you paste is switched to this language automatically. |

#### Output Detail

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDetails` | boolean | `false` | Open each ad's own page to add the full description, the complete photo gallery, map coordinates, the listing date, and every extra specification the seller filled in (rooms, area, floor, house type, car year and mileage, and so on). Leave off for fast, inexpensive runs that still return the title, price, thumbnail and results-page columns. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | The largest number of ads to collect in total, across all URLs and keywords. Set to `0` for no limit (an internal ceiling of 50,000 ads still applies). Ads are collected a full page at a time, so the final count may go slightly over this number. |

### Output

Each ad is one row. Here is a representative real-estate result with full details enabled:

```json
{
    "adId": "51837462",
    "url": "https://www.ss.lv/msg/en/real-estate/flats/riga/centre/gjcdi.html",
    "title": "Sell, 2-room flat, 54 m², Riga, Centre, Latgales street",
    "category": "Flats",
    "categoryPath": "real-estate/flats/riga/centre/sell",
    "price": 64375,
    "priceCurrency": "EUR",
    "priceRaw": "64 375 € (1 497.09 €/m²)",
    "pricePerSqm": 1497.09,
    "city": "Riga",
    "district": "Centre",
    "street": "Latgales 109",
    "rooms": 2,
    "area": 54,
    "floor": 4,
    "totalFloors": 5,
    "houseType": "Brick",
    "series": "Pre-war",
    "latitude": 56.9421,
    "longitude": 24.1503,
    "listedAt": "2026-07-14T09:32:00",
    "description": "Spacious two-room apartment in the heart of Riga, renovated in 2023...",
    "listingColumns": [
        { "label": "Street", "value": "Latgales 109" },
        { "label": "Rooms", "value": "2" },
        { "label": "m²", "value": "54" },
        { "label": "Floor", "value": "4/5" },
        { "label": "Series", "value": "Pre-war" }
    ],
    "attributes": {
        "tdo_2": { "key": "tdo_2", "label": "House type", "value": "Brick" },
        "tdo_6": { "key": "tdo_6", "label": "Series", "value": "Pre-war" }
    },
    "images": [
        "https://i.ss.lv/gallery/6/153/38200/7639901.800.jpg",
        "https://i.ss.lv/gallery/6/153/38200/7639902.800.jpg"
    ],
    "imageThumbnail": "https://i.ss.lv/gallery/6/153/38200/7639901.t.jpg",
    "language": "en",
    "scrapedAt": "2026-07-17T12:00:00+00:00"
}
```

#### Core Fields — on every ad

| Field | Type | Description |
|-------|------|-------------|
| `adId` | string | The ad's own SS.LV id. Stable key for deduplication across runs. |
| `url` | string | Direct link to the ad page. |
| `title` | string | Ad title as shown in the results. |
| `category` | string | Leaf category, e.g. `Flats` or `Cars`. |
| `categoryPath` | string | Full category path, e.g. `real-estate/flats/riga/centre/sell`. |
| `language` | string | Which language the row was collected in (`en`, `lv`, or `ru`). |
| `scrapedAt` | string | ISO-8601 timestamp of the run. |

#### Pricing — on every ad

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Parsed numeric price. |
| `priceCurrency` | string | Currency, usually `EUR`. |
| `priceRaw` | string | Price exactly as shown, preserving forms like "by agreement" or monthly rent. |
| `pricePerSqm` | number | Price per square metre, where the site shows it (real estate). |

#### Results-Page Data — on every ad

| Field | Type | Description |
|-------|------|-------------|
| `listingColumns` | object\[] | The label/value columns SS.LV shows on the results page (street, rooms, area, floor, and so on) — lightweight structured basics without a per-ad detail fetch. |
| `imageThumbnail` | string | Thumbnail image from the results row. |

#### Location — with full details

| Field | Type | Description |
|-------|------|-------------|
| `city` | string | City. |
| `district` | string | District or neighbourhood. |
| `street` | string | Street and house number. |
| `latitude` | number | Latitude from the ad's map pin (ads with a map location). |
| `longitude` | number | Longitude from the ad's map pin (ads with a map location). |

#### Property & Category Specs — with full details

| Field | Type | Description |
|-------|------|-------------|
| `rooms` | number | Number of rooms (real estate). |
| `area` | number | Area in m² (real estate). |
| `floor` | number | Floor number. |
| `totalFloors` | number | Total floors in the building. |
| `houseType` | string | Building material or house type. |
| `series` | string | Building series (real estate). |
| `attributes` | object | Every seller-filled specification, keyed by its stable SS.LV field id — carries per-category data like car year, mileage, engine and gearbox, or job details, without a fixed schema. |

#### Rich Detail — with full details

| Field | Type | Description |
|-------|------|-------------|
| `description` | string | Full ad body text. |
| `images` | string\[] | The complete photo gallery as full-size image URLs. |
| `listedAt` | string | ISO-8601 date and time the ad was listed. |

Fields under "with full details" are populated when `includeDetails` is enabled; on the fast default run each ad still returns its core fields, pricing, results-page columns and thumbnail.

### Tips for Best Results

- **Pre-filter on SS.LV, then copy the URL** — set the region, price band and other filters directly on ss.lv, then paste the resulting address. The actor keeps every filter you applied, so you collect exactly the slice you want.
- **Point at a category that lists ads, not a top-level index** — an index page (like a section landing page) has no ads of its own; give the actor a leaf category or a filtered search and it goes straight to the listings.
- **Turn on full details for description, coordinates, listing date and specs** — leave it off for fast, low-cost runs, and switch it on when you need geo data, the listing date, the full gallery, or the structured `attributes` map.
- **Set `maxResults` to a multiple of 30** — SS.LV serves 30 ads per page and the run overshoots to the next page boundary rather than trimming, so round numbers of pages give you a predictable count.
- **Get structured basics for free** — even with details off, `listingColumns` carries the street, rooms, area and floor SS.LV shows on the results page, so you get usable structure without paying for a per-ad detail fetch.
- **Match the language to the labels you want** — the ads are identical across English, Latvian and Russian; only the field labels change, so pick the language your downstream tools expect.
- **Combine keywords and URLs in one run** — mix a keyword search with several category URLs to assemble a broad, cross-section dataset in a single pass.

### Pricing

**From $3.00 per 1,000 results** — full coverage of every SS.LV section at well below the going rate for a real-estate-only alternative. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.36 | $0.34 | $0.32 | $0.30 |
| 1,000 | $3.60 | $3.40 | $3.20 | $3.00 |
| 10,000 | $36.00 | $34.00 | $32.00 | $30.00 |
| 100,000 | $360.00 | $340.00 | $320.00 | $300.00 |

A "result" is one ad row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, price monitoring, and data analysis. You are responsible for complying with applicable laws and SS.LV's Terms of Service. Collect only publicly available information, respect personal data and privacy regulations, and do not use extracted data for spam, harassment, or any unlawful purpose.

# Actor input Schema

## `startUrls` (type: `array`):

Paste one or more SS.LV category pages, search-result pages, or individual ad pages (for example 'https://www.ss.lv/en/real-estate/flats/riga/centre/sell/' or 'https://www.ss.lv/en/transport/cars/audi/'). The easiest way: go to ss.lv, set the filters you want in your browser, then copy the address from the address bar. Every page of results is followed automatically.

## `searchQueries` (type: `array`):

Type what you're looking for, for example 'audi', 'dzīvoklis Rīgā', or 'iphone'. Each keyword is searched across the whole of SS.LV and every page of results is collected. Use this when you don't want to build a URL by hand.

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

Which language version of SS.LV to read. This changes the wording of labels and categories in your results — the ads themselves are the same in all three. Any URL you paste above is automatically switched to this language.

## `includeDetails` (type: `boolean`):

Open each ad's own page to add the full description, the complete photo gallery, map coordinates, the listing date, and every extra specification the seller filled in (rooms, area, floor, house type, car year/mileage, and so on). Leave this off (the default) for fast, inexpensive runs that still give you the title, price, photo thumbnail and the columns shown on the results page. Turning it on makes one extra request per ad, so runs take noticeably longer.

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

The largest number of ads to collect in total, across all URLs and keywords. Set to 0 for no limit (an internal ceiling of 50,000 ads per run still applies so a run can't go on forever). Ads are collected a full page at a time, so your final count may go slightly over this number.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.ss.lv/en/real-estate/flats/riga/centre/sell/"
  ],
  "searchQueries": [],
  "language": "en",
  "maxResults": 100
}
```

# Actor output Schema

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

Table of ads with title, price, location, and key specs.

## `detailed` (type: `string`):

Per-ad detail view (populated when full details are enabled): price/m², rooms, area, floor, house type, coordinates, listing date, description, and photo.

# 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 = {
    "startUrls": [
        "https://www.ss.lv/en/real-estate/flats/riga/centre/sell/"
    ],
    "searchQueries": [],
    "language": "en",
    "includeDetails": false,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/ss-lv-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 = {
    "startUrls": ["https://www.ss.lv/en/real-estate/flats/riga/centre/sell/"],
    "searchQueries": [],
    "language": "en",
    "includeDetails": False,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/ss-lv-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 '{
  "startUrls": [
    "https://www.ss.lv/en/real-estate/flats/riga/centre/sell/"
  ],
  "searchQueries": [],
  "language": "en",
  "includeDetails": false,
  "maxResults": 100
}' |
apify call solidcode/ss-lv-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/ss-lv-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SS.LV Latvia Classifieds Scraper",
        "description": "[💰 $3 / 1K] Extract classified ads from SS.LV / SS.COM, Latvia's biggest marketplace — real estate, cars, jobs, electronics and more. Get price, price/m², location, photos, descriptions and per-category specs. Paste any SS.LV URL or search by keyword, in English, Latvian or Russian.",
        "version": "1.0",
        "x-build-id": "zYmvptIWjrh7yFvD5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~ss-lv-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-ss-lv-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/solidcode~ss-lv-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-ss-lv-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/solidcode~ss-lv-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-ss-lv-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",
                "properties": {
                    "startUrls": {
                        "title": "SS.LV URLs",
                        "type": "array",
                        "description": "Paste one or more SS.LV category pages, search-result pages, or individual ad pages (for example 'https://www.ss.lv/en/real-estate/flats/riga/centre/sell/' or 'https://www.ss.lv/en/transport/cars/audi/'). The easiest way: go to ss.lv, set the filters you want in your browser, then copy the address from the address bar. Every page of results is followed automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Type what you're looking for, for example 'audi', 'dzīvoklis Rīgā', or 'iphone'. Each keyword is searched across the whole of SS.LV and every page of results is collected. Use this when you don't want to build a URL by hand.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "lv",
                            "ru"
                        ],
                        "type": "string",
                        "description": "Which language version of SS.LV to read. This changes the wording of labels and categories in your results — the ads themselves are the same in all three. Any URL you paste above is automatically switched to this language."
                    },
                    "includeDetails": {
                        "title": "Include full ad details",
                        "type": "boolean",
                        "description": "Open each ad's own page to add the full description, the complete photo gallery, map coordinates, the listing date, and every extra specification the seller filled in (rooms, area, floor, house type, car year/mileage, and so on). Leave this off (the default) for fast, inexpensive runs that still give you the title, price, photo thumbnail and the columns shown on the results page. Turning it on makes one extra request per ad, so runs take noticeably longer."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "The largest number of ads to collect in total, across all URLs and keywords. Set to 0 for no limit (an internal ceiling of 50,000 ads per run still applies so a run can't go on forever). Ads are collected a full page at a time, so your final count may go slightly over this number."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
