# Europages Scraper (`solidcode/europages-scraper`) Actor

\[💰 $10.0 / 1K] Extract B2B company and supplier profiles from Europages — name, description, address, phone, email, website, VAT number, employee count, founding year, business types, and categories. Search by keyword + country, or paste Europages URLs.

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

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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.md):

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

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

## Europages Scraper

Pull verified B2B supplier and manufacturer profiles from Europages at scale — company name, description, full postal address, phone, email, VAT number, employee count, founding year, supplier type, and precise latitude/longitude for every company across the pan-European industrial directory. Built for procurement teams, B2B sales and lead-gen, and supply-chain analysts who need a clean, structured supplier dataset without browsing the directory one company at a time.

### Why This Scraper?

- **Verified VAT IDs for cross-border tax validation** — capture each supplier's VAT number (e.g. `DE323827758`) for KYC, due-diligence, and reverse-charge invoicing across the EU.
- **Precise latitude/longitude on every supplier** — exact geo coordinates plus full street address, city, postal code, and ISO country code for territory mapping and catchment analysis.
- **25 country filters from Germany to Türkiye to China** — restrict suppliers to any mix of 25 markets, or leave it open to search all of Europe at once.
- **9 localized language editions** — read supplier descriptions in their native market language: English, German, French, Italian, Spanish, Dutch, Portuguese, Polish, or Turkish.
- **Four supplier-type filters** — narrow to Manufacturers / Producers, Wholesalers, Distributors, or Service Providers so your list matches your sourcing intent.
- **Supplier-trust signals built in** — response rate, average response time, and declared certificate counts on every profile to score vendor reliability before you reach out.
- **Company-size segmentation fields** — founding year and employee-count band on each record let you filter for established manufacturers or fast-growing SMEs.
- **Product/service categories and keywords** — every supplier carries its Europages category and a keyword list, so you can cluster a market by what each company actually makes.
- **Keyword + country search builder, no hand-built URLs** — type "industrial valves" and pick a country; the actor assembles every search for you and batches many terms in one run.

### Use Cases

**Lead Generation & Sales Prospecting**
- Build targeted supplier contact lists with website, phone, and email where published
- Segment prospects by supplier type — reach only Manufacturers or only Distributors
- Localize outreach by pulling each edition's native-language company descriptions
- Score leads up front using response rate and certificate counts

**Procurement & Supplier Sourcing**
- Shortlist qualified manufacturers for a specific component across multiple countries
- Validate vendor legitimacy with VAT IDs and declared certifications before RFQs
- Compare supplier density for a category between Germany, France, Italy, and beyond
- Find alternate or backup suppliers to de-risk a single-source supply chain

**Market & Competitive Research**
- Map the competitive landscape of an industrial niche across 25 markets
- Track which categories and keywords competitors position themselves under
- Benchmark company sizes in a sector using founding year and employee bands
- Quantify a market by counting suppliers per country and supplier type

**Supply-Chain & Territory Analysis**
- Plot suppliers on a map using per-company latitude/longitude for logistics planning
- Cluster vendors by distribution area to optimize regional sourcing
- Identify supplier concentration risk in a single city or postal region
- Feed geo-tagged supplier data into routing and catchment models

**Data Enrichment & CRM Integration**
- Enrich an existing vendor database with VAT IDs, geo, and firmographics
- De-duplicate and standardize supplier records across European markets
- Power B2B directories and analytics dashboards with fresh company data
- Keep a sourcing CRM current with response-time and certification signals

### Getting Started

#### Simple Keyword Search

The fastest way to start — one product term, all of Europe:

```json
{
    "searchTerms": ["cardboard packaging"],
    "maxResults": 50
}
````

#### Keyword + Country + Supplier Type

Narrow to German and French manufacturers of industrial valves:

```json
{
    "searchTerms": ["industrial valves"],
    "countries": ["de", "fr"],
    "supplierTypes": ["manufacturer"],
    "maxResults": 200
}
```

#### Localized Edition (Native-Language Descriptions)

Pull olive oil suppliers from the Spanish edition for native-language company text:

```json
{
    "searchTerms": ["aceite de oliva"],
    "countries": ["es"],
    "language": "es",
    "maxResults": 100
}
```

#### Paste Europages URLs Directly

Mix keyword search pages, category listings, and a single company profile in one run:

```json
{
    "startUrls": [
        "https://www.europages.co.uk/en/search?q=packaging",
        "https://www.europages.fr/entreprises/emballages%20en%20carton.html"
    ],
    "maxResults": 100
}
```

#### Full-Featured Example

Multiple terms across several countries, filtered by supplier type:

```json
{
    "searchTerms": ["olive oil", "pasta machinery"],
    "countries": ["it", "es", "gr"],
    "supplierTypes": ["manufacturer", "distributor"],
    "language": "en",
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["cardboard packaging"]` | Products, services, or industry keywords to search. Each term is combined with every country — 2 terms x 3 countries = 6 searches. |
| `countries` | string\[] | `[]` (all of Europe) | Restrict suppliers to these markets. 25 options: Germany, France, United Kingdom, Italy, Spain, Netherlands, Belgium, Poland, Türkiye, Austria, Switzerland, Portugal, Sweden, Denmark, Norway, Finland, Ireland, Czech Republic, Greece, Romania, Hungary, Bulgaria, Ukraine, United States, China. |
| `startUrls` | string\[] | `[]` | Paste Europages URLs directly — keyword search pages, category listing pages, or individual company profiles. Filters baked into the URL are honored as-is. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `language` | select | `English` | Europages language edition. Sets both the result language and the language of company descriptions. 9 editions: English, German, French, Italian, Spanish, Dutch, Portuguese, Polish, Turkish. |
| `supplierTypes` | string\[] | `[]` (all types) | Only include companies matching these business types: Manufacturer / Producer, Wholesaler, Distributor, Service provider. Leave empty for every type. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Hard cap on total company rows across all searches and URLs. Set to `0` for no cap. The actor keeps the full final page even if it slightly overshoots the cap. |

### Output

Each row is one flat company record. Null or unpublished fields are omitted from the row.

```json
{
    "name": "Verpackungen Müller GmbH",
    "description": "Manufacturer of corrugated cardboard packaging and custom shipping boxes for industrial clients across Europe.",
    "supplierTypes": ["Manufacturer / Producer"],
    "categories": ["Packaging, cardboard"],
    "keywords": ["corrugated boxes", "shipping cartons", "custom packaging"],
    "website": "https://www.verpackungen-mueller.de",
    "email": "kontakt@verpackungen-mueller.de",
    "phone": "+49 221 1234567",
    "fax": "+49 221 1234568",
    "addressLines": ["Industriestraße 42"],
    "city": "Köln",
    "postalCode": "50667",
    "countryCode": "DE",
    "latitude": 50.9375,
    "longitude": 6.9603,
    "vatId": "DE323827758",
    "employeeCount": "50-99",
    "foundingYear": 2004,
    "distributionArea": "Worldwide",
    "responseRate": 92,
    "averageResponseTime": "< 24h",
    "certificatesCount": 3,
    "logoUrl": "https://cdn.europages.com/logos/verpackungen-mueller.png",
    "companyId": "12345678",
    "slug": "verpackungen-mueller-gmbh",
    "profileUrl": "https://www.europages.co.uk/en/company/verpackungen-mueller-gmbh",
    "searchUrl": "https://www.europages.co.uk/en/companies/germany/manufacturer producer/cardboard packaging.html",
    "contentLanguage": "en"
}
```

#### Identity

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Company / supplier name |
| `description` | string | Company "about" / description text |
| `companyId` | string | Europages internal company identifier |
| `slug` | string | Europages URL slug |
| `profileUrl` | string | Canonical Europages company profile URL |
| `searchUrl` | string | The search or listing URL the company was found on |
| `contentLanguage` | string | Language edition the record was scraped from |

#### Firmographics

| Field | Type | Description |
|-------|------|-------------|
| `supplierTypes` | string\[] | Business types: Manufacturer / Producer, Custom Manufacturer, Distributor, Service Provider, Wholesaler |
| `categories` | string\[] | Europages product/service categories the company is listed under |
| `keywords` | string\[] | Product / service keywords associated with the company |
| `employeeCount` | string | Employee-count band (e.g. "50-99") |
| `foundingYear` | number | Year the company was founded |
| `distributionArea` | string | Stated distribution / delivery area |
| `vatId` | string | VAT / tax identification number (when published) |

#### Contact

| Field | Type | Description |
|-------|------|-------------|
| `website` | string | Company homepage URL |
| `email` | string | Contact email (when published) |
| `phone` | string | Contact phone number |
| `fax` | string | Fax number (when published) |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `addressLines` | string\[] | Street address lines |
| `city` | string | City |
| `postalCode` | string | Postal / ZIP code |
| `countryCode` | string | ISO-2 country code |
| `latitude` | number | Geo latitude (when available) |
| `longitude` | number | Geo longitude (when available) |

#### Trust Signals

| Field | Type | Description |
|-------|------|-------------|
| `responseRate` | number | Stated response rate to inquiries |
| `averageResponseTime` | string | Stated average response time (e.g. "< 24h") |
| `certificatesCount` | number | Number of certificates declared on the profile |
| `logoUrl` | string | Company logo image URL |

### Tips for Best Results

- **Start small to validate.** Set `maxResults` to 25-50 on your first run to confirm the data matches your sourcing intent, then scale up.
- **Combine country + supplier-type filters to stay on target.** A keyword search always returns the most relevant suppliers — Europages shows related results rather than an empty page — so pair your term with `countries` and `supplierTypes` to keep the list tightly scoped.
- **Set expectations on contacts.** Email and fax are best-effort and are gated or unpublished by many European suppliers; phone and website are far more consistently available. VAT IDs appear on roughly half of profiles.
- **Paste a company profile URL for a single enriched record.** Drop one Europages company URL into `startUrls` to pull that supplier's full profile, including any published VAT ID, email, and structured address.
- **Match the edition to the market.** Set `language` to the supplier's home language (e.g. German for German suppliers) to get the richest native descriptions and keyword coverage.
- **Split large pulls across terms or countries.** For very large datasets, run several focused keyword + country combinations rather than one broad search — narrower searches return more relevant, less duplicated suppliers.
- **De-duplication is automatic.** The same company found across overlapping searches is billed and returned only once, keyed on its Europages company ID.

### Pricing

**$10.00 per 1,000 results** — flat pay-per-result, undercutting comparable Europages extractors.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $1.00 |
| 1,000 | $10.00 |
| 10,000 | $100.00 |
| 100,000 | $1,000.00 |

A "result" is one company row in the output dataset. No compute charges — you only pay per result returned. Platform fees depend on your Apify plan.

### 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 B2B research, supplier sourcing, market analysis, and lead generation. Users are responsible for complying with applicable laws — including the GDPR and other data-protection regulations — and with Europages' Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and respect the marketing and contact preferences of the companies you collect.

# Actor input Schema

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

Products, services, or industry keywords to search on Europages (e.g. 'cardboard packaging', 'industrial valves', 'olive oil'). Each term is combined with every entry in Countries — for example, 2 terms x 3 countries = 6 searches.

## `countries` (type: `array`):

Restrict suppliers to these countries. Leave empty to search all of Europe (every country). Combined with each Search Term.

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

Paste one or more Europages URLs. Accepts keyword search pages (e.g. https://www.europages.co.uk/en/search?q=packaging), category listing pages (e.g. https://www.europages.fr/entreprises/emballages%20en%20carton.html), and individual company profiles. Filters baked into the URL are honored as-is.

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

Which Europages language edition to query. Each edition is a separate localized site, so this sets both the result language and the company descriptions you receive. Available editions: English, German, French, Italian, Spanish, Dutch, Portuguese, Polish, Turkish.

## `supplierTypes` (type: `array`):

Only include companies matching these business types. Leave empty to include every type of supplier.

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

Hard cap on total company rows across all searches and URLs. Default 100 — increase for bigger runs, or set to 0 for no cap. An effective upper limit of 100,000 rows per run always applies to prevent runaway pagination, so a value above 100,000 (or 0 / no cap) collects at most 100,000 rows. The actor stops requesting new listing pages once your number is reached but keeps the full final page even if it slightly overshoots. To gather very large datasets, split a request across multiple keywords or countries.

## Actor input object example

```json
{
  "searchTerms": [
    "cardboard packaging"
  ],
  "countries": [],
  "startUrls": [],
  "language": "en",
  "supplierTypes": [],
  "maxResults": 100
}
```

# Actor output Schema

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

Table of scraped companies with the most useful columns at a glance.

# 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 = {
    "searchTerms": [
        "cardboard packaging"
    ],
    "countries": [],
    "startUrls": [],
    "language": "en",
    "supplierTypes": [],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/europages-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 = {
    "searchTerms": ["cardboard packaging"],
    "countries": [],
    "startUrls": [],
    "language": "en",
    "supplierTypes": [],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/europages-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 '{
  "searchTerms": [
    "cardboard packaging"
  ],
  "countries": [],
  "startUrls": [],
  "language": "en",
  "supplierTypes": [],
  "maxResults": 100
}' |
apify call solidcode/europages-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Europages Scraper",
        "description": "[💰 $10.0 / 1K] Extract B2B company and supplier profiles from Europages — name, description, address, phone, email, website, VAT number, employee count, founding year, business types, and categories. Search by keyword + country, or paste Europages URLs.",
        "version": "1.0",
        "x-build-id": "FOGSAnIKlHuUgLZKX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~europages-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-europages-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~europages-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-europages-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~europages-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-europages-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": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Products, services, or industry keywords to search on Europages (e.g. 'cardboard packaging', 'industrial valves', 'olive oil'). Each term is combined with every entry in Countries — for example, 2 terms x 3 countries = 6 searches.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Restrict suppliers to these countries. Leave empty to search all of Europe (every country). Combined with each Search Term.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "de",
                                "fr",
                                "gb",
                                "it",
                                "es",
                                "nl",
                                "be",
                                "pl",
                                "tr",
                                "at",
                                "ch",
                                "pt",
                                "se",
                                "dk",
                                "no",
                                "fi",
                                "ie",
                                "cz",
                                "gr",
                                "ro",
                                "hu",
                                "bg",
                                "ua",
                                "us",
                                "cn"
                            ],
                            "enumTitles": [
                                "Germany",
                                "France",
                                "United Kingdom",
                                "Italy",
                                "Spain",
                                "Netherlands",
                                "Belgium",
                                "Poland",
                                "Türkiye",
                                "Austria",
                                "Switzerland",
                                "Portugal",
                                "Sweden",
                                "Denmark",
                                "Norway",
                                "Finland",
                                "Ireland",
                                "Czech Republic",
                                "Greece",
                                "Romania",
                                "Hungary",
                                "Bulgaria",
                                "Ukraine",
                                "United States",
                                "China"
                            ]
                        },
                        "default": []
                    },
                    "startUrls": {
                        "title": "Europages URLs",
                        "type": "array",
                        "description": "Paste one or more Europages URLs. Accepts keyword search pages (e.g. https://www.europages.co.uk/en/search?q=packaging), category listing pages (e.g. https://www.europages.fr/entreprises/emballages%20en%20carton.html), and individual company profiles. Filters baked into the URL are honored as-is.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language / Site Edition",
                        "enum": [
                            "en",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "nl",
                            "pt",
                            "pl",
                            "tr"
                        ],
                        "type": "string",
                        "description": "Which Europages language edition to query. Each edition is a separate localized site, so this sets both the result language and the company descriptions you receive. Available editions: English, German, French, Italian, Spanish, Dutch, Portuguese, Polish, Turkish.",
                        "default": "en"
                    },
                    "supplierTypes": {
                        "title": "Supplier Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include companies matching these business types. Leave empty to include every type of supplier.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "manufacturer",
                                "wholesaler",
                                "distributor",
                                "service_provider"
                            ],
                            "enumTitles": [
                                "Manufacturer / Producer",
                                "Wholesaler",
                                "Distributor",
                                "Service provider"
                            ]
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total company rows across all searches and URLs. Default 100 — increase for bigger runs, or set to 0 for no cap. An effective upper limit of 100,000 rows per run always applies to prevent runaway pagination, so a value above 100,000 (or 0 / no cap) collects at most 100,000 rows. The actor stops requesting new listing pages once your number is reached but keeps the full final page even if it slightly overshoots. To gather very large datasets, split a request across multiple keywords or countries.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
