# Europages Supplier Scraper (`automation-lab/europages-supplier-scraper`) Actor

Extract public Europages supplier leads with company profiles, locations, descriptions, badges, products, and contact entry URLs.

- **URL**: https://apify.com/automation-lab/europages-supplier-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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.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 Supplier Scraper

Extract supplier leads from Europages category and company search result pages.

### What This Actor Does

Europages Supplier Scraper collects public B2B supplier listings from Europages.

It is built for lead generation, supplier discovery, market mapping, sourcing research, and competitor monitoring.

The actor reads Europages result pages with HTTP requests and parses the server-rendered HTML plus embedded structured data.

### Data Source

The actor targets public Europages pages such as:

`https://www.europages.co.uk/companies/electronics.html`

It supports category pages, search-result pages, and generated company search URLs from keywords.

### Input Sources

You can provide direct URLs.

You can provide search terms.

You can provide category names.

You can combine all three modes in one run.

### Start URLs

Use `startUrls` when you already have Europages URLs.

Example:

```json
[
  { "url": "https://www.europages.co.uk/companies/electronics.html" }
]
````

### Search Terms

Use `searchTerms` to search for supplier topics.

Example:

```json
["electronics", "metal machining", "industrial packaging"]
```

The actor converts terms into Europages company search URLs.

### Categories

Use `categories` for category-style scraping.

Example:

```json
["electronics", "industrial machinery"]
```

Categories are normalized into Europages URL slugs.

### Limits

`maxItems` controls the total number of supplier rows saved.

`maxPagesPerSearch` controls pagination for each source.

Small test runs should use 5 to 20 items.

Large sourcing exports can increase the limit.

### Proxy Settings

Europages can expose WAF and CAPTCHA configuration.

The actor supports Apify Proxy.

Residential proxy is the safest default for challenged runs.

Direct HTTP can work for many small category pages.

### Output Fields

Each dataset row represents one supplier listing.

The actor exports:

- supplier name
- Europages profile URL
- source URL
- source type
- source value
- search term or category
- page number
- result position
- city
- country
- combined location
- public description
- badges
- supplier types
- employee count
- founding year
- product count
- sample product names
- public contact-entry URLs
- public website URLs when present
- area served
- scrape timestamp

### Supplier Name

`name` is the supplier or company name shown by Europages.

The field is normalized for extra whitespace.

### Profile URL

`profileUrl` is the public Europages company profile URL from the result card.

This is useful for deduplication and manual review.

### Location

The actor extracts city and country from structured JSON-LD when available.

It also emits a combined `location` string.

### Description

`description` is the public supplier summary shown on the result page.

Some descriptions are truncated by Europages.

### Badges

`badges` captures visible trust and feature hints.

Examples include certificate hints, verified markers, and manufacturing badges.

### Supplier Types

`supplierTypes` captures visible role tags.

Examples include manufacturer, producer, distributor, service provider, and wholesaler.

### Products

`productCount` captures the visible number of listed products when present.

`productNames` includes sample product names shown in the result card.

### Contact Entry URLs

`contactEntryUrls` contains public Europages URLs that lead to contact, portfolio, or profile actions.

The actor does not bypass login, forms, or protected contact reveal flows.

### Website URLs

`websiteUrls` contains external website links when they are directly visible in public HTML.

Many Europages cards do not expose an external website link on the search result page.

### Pagination

The actor follows the next-page link when it is present.

It stops at `maxPagesPerSearch`.

It also stops when `maxItems` is reached.

### Deduplication

The actor deduplicates by `profileUrl` during a run.

If the same supplier appears across multiple sources, only the first occurrence is saved.

### Example Input

```json
{
  "startUrls": [
    { "url": "https://www.europages.co.uk/companies/electronics.html" }
  ],
  "searchTerms": ["electronics"],
  "maxItems": 20,
  "maxPagesPerSearch": 1,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Example Output

```json
{
  "name": "Frezamet Bis Sp. z o.o",
  "profileUrl": "https://www.europages.co.uk/en/company/frezamet-bis-sp-z-oo-22294309",
  "sourceUrl": "https://www.europages.co.uk/companies/electronics.html",
  "sourceType": "startUrl",
  "sourceValue": "https://www.europages.co.uk/companies/electronics.html",
  "positionOnPage": 1,
  "pageNumber": 1,
  "city": "Orzesze",
  "country": "PL",
  "location": "Orzesze, PL",
  "description": "Frezamet Bis is a Polish company specializing in precision machining of metals and plastics.",
  "badges": ["Certificates: 1"],
  "supplierTypes": ["Manufacturer/Producer"],
  "employeeCount": "20-49",
  "productCount": 39,
  "productNames": ["Turning on CNC lathes"],
  "contactEntryUrls": ["https://www.europages.co.uk/en/company/frezamet-bis-sp-z-oo-22294309"],
  "websiteUrls": [],
  "areaServed": "europe",
  "scrapedAt": "2026-05-15T08:17:25.388Z"
}
```

### Use Cases

Use this actor to build supplier prospect lists.

Use it to compare suppliers across countries.

Use it to collect sourcing candidates for a product category.

Use it to monitor competitor or distributor presence on Europages.

Use it to enrich internal CRM research with public supplier metadata.

### Persona Workflows

Sourcing teams can collect candidates for a product category, keep the Europages profile URL as the source of truth, and shortlist suppliers by country, supplier type, employee count, and product count.

B2B sales teams can create focused prospect lists from category pages, export the rows to CSV, and enrich only the companies that match their ideal customer profile.

Procurement analysts can run the same category every week or month, compare `scrapedAt` timestamps, and detect new or changed supplier listings without manually reviewing every result page.

Market researchers can map how many suppliers appear in a category, which countries dominate the visible listings, and which role tags are common across the market.

### Who Is It For

This actor is for sourcing teams, B2B sales teams, procurement analysts, market researchers, distributor managers, and lead-generation operators who need structured supplier lists from public Europages pages.

Use it when you need repeatable exports instead of manually opening category pages, copying supplier names, and preserving source context by hand.

### Recommended Workflow

1. Start with one Europages category URL or one search term.

2. Set `maxItems` to 20 and `maxPagesPerSearch` to 1 for the first validation run.

3. Inspect the dataset columns you care about: `name`, `profileUrl`, `country`, `supplierTypes`, `productCount`, `contactEntryUrls`, and `websiteUrls`.

4. Remove source URLs or terms that produce irrelevant suppliers.

5. Increase `maxPagesPerSearch` and `maxItems` for a production export.

6. Export the dataset to CSV or Excel for review, or JSON for enrichment.

7. Use Apify Proxy if direct requests start returning WAF or challenge responses.

### Sales Workflow

1. Enter one category such as `electronics` or a direct Europages category URL.

2. Export `name`, `profileUrl`, `country`, `supplierTypes`, `productCount`, and `websiteUrls`.

3. Remove suppliers that do not match your territory or product focus.

4. Send the remaining profiles to a website-contact or CRM enrichment workflow.

5. Keep `sourceValue`, `pageNumber`, and `positionOnPage` so each lead can be traced back to the original Europages result.

### Procurement Workflow

1. Create one run per category, product family, or sourcing region.

2. Use `country`, `employeeCount`, `supplierTypes`, and `productNames` to shortlist candidates.

3. Review the public Europages profile before contacting a supplier.

4. Schedule refreshes for key categories and compare exports over time.

5. Use `scrapedAt` to separate new supplier research from older sourcing snapshots.

### Market Mapping Workflow

1. Run several related categories with a shared `maxItems` limit.

2. Group exported rows by `country`, `supplierTypes`, and `sourceValue`.

3. Compare product counts and badge fields to identify mature supplier clusters.

4. Review duplicates by `profileUrl` to see which companies appear across multiple categories.

5. Feed the dataset into BI tools or spreadsheets for category-level reporting.

### Data Freshness

Rows reflect the public Europages page at run time.

The actor includes `scrapedAt` so you can track when a row was collected.

### Respectful Scraping

The actor uses HTTP requests and conservative pagination.

Keep limits aligned with your business need.

Avoid repeated large runs over the same category when a smaller refresh is enough.

### Limitations

Europages may hide some contact details behind interactive flows.

The actor only exports publicly available URLs and text found in the initial HTML.

Some result cards do not contain external websites.

Some descriptions are truncated by Europages.

Upstream page layout changes can affect selectors.

### Troubleshooting

If output is empty, check that the URL is a Europages company search or category page.

If the run fails with a challenge message, enable Apify Proxy.

If pagination stops early, raise `maxPagesPerSearch`.

If you see repeated suppliers, lower overlapping input sources or rely on `profileUrl` deduplication.

### Cost Control

Every saved supplier result is charged as a result event.

Use small limits for tests.

Raise limits only after confirming that the source returns the fields you need.

### How much does it cost to scrape Europages supplier leads?

This actor uses pay-per-event pricing. Each run has a small start event and each saved supplier row is charged as a result event.

Current configured BRONZE pricing is:

| Event | When it is charged | Price |
|---|---:|---:|
| Run started | Once per run | $0.005 |
| Result extracted | Each saved supplier row | $0.00014896 |

Example estimates at BRONZE rates:

| Run size | Estimated actor charge |
|---:|---:|
| 20 supplier rows | About $0.0080 |
| 100 supplier rows | About $0.0199 |
| 1,000 supplier rows | About $0.1540 |

If you are testing with a $5 monthly platform credit, these event prices are low enough for thousands of small validation rows before normal Apify platform usage costs are considered. Actual total spend depends on your account plan, proxy usage, and run volume.

Use `maxItems` and `maxPagesPerSearch` to control spend before scaling to larger exports.

### Dataset Export

The default dataset can be exported as JSON, CSV, Excel, XML, or RSS through Apify.

Use CSV or Excel for sales workflows.

Use JSON for enrichment pipelines.

### Integration Ideas

Send exported rows to a CRM.

Join `profileUrl` against existing supplier records.

Filter by country and supplier type.

Use `productNames` to identify relevant supplier capabilities.

Use `badges` and `employeeCount` to prioritize outreach.

### Integration Workflows

CRM teams can export CSV rows and import `name`, `profileUrl`, `country`, `supplierTypes`, and `websiteUrls` as new lead records.

Data teams can call the actor through the Apify API, read the default dataset, and push JSON rows into a warehouse or enrichment queue.

Automation teams can schedule weekly category runs, then trigger downstream workflows only when new `profileUrl` values appear.

AI-agent workflows can call the actor through Apify MCP and ask the model to summarize suppliers by country, product focus, or supplier type.

### API Usage

Use the Apify API when you want to run the actor from scripts, scheduled jobs, enrichment workflows, or backend services.

Node.js example:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/europages-supplier-scraper').call({
  startUrls: [{ url: 'https://www.europages.co.uk/companies/electronics.html' }],
  maxItems: 20,
  maxPagesPerSearch: 1,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Python example:

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("automation-lab/europages-supplier-scraper").call(
    run_input={
        "startUrls": [{"url": "https://www.europages.co.uk/companies/electronics.html"}],
        "maxItems": 20,
        "maxPagesPerSearch": 1,
    }
)

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

cURL example:

```bash
curl "https://api.apify.com/v2/acts/automation-lab~europages-supplier-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://www.europages.co.uk/companies/electronics.html"}],
    "maxItems": 20,
    "maxPagesPerSearch": 1
  }'
```

### MCP

Use this actor through Apify MCP when an assistant needs supplier leads as structured data. The hosted Apify MCP endpoint uses HTTP transport at `https://mcp.apify.com`, and the actor can be exposed as a tool with the `tools` query parameter.

Keep inputs narrow for interactive workflows, then increase limits for scheduled sourcing jobs.

Claude CLI setup example:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/europages-supplier-scraper"
```

Claude Desktop or Cursor JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/europages-supplier-scraper",
      "env": {
        "APIFY_TOKEN": "your-apify-token"
      }
    }
  }
}
```

VS Code MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/europages-supplier-scraper",
      "headers": {
        "Authorization": "Bearer ${input:apify-token}"
      }
    }
  }
}
```

Example prompts:

- "Find up to 20 electronics suppliers from Europages and return their names, countries, profile URLs, and supplier types."
- "Scrape the Europages industrial machinery category and summarize which suppliers mention CNC or machining."
- "Create a supplier lead table from this Europages category URL and include the source URL for each result."

### Legality

This actor extracts public information from Europages pages.

You are responsible for using the output in line with applicable laws, platform terms, privacy rules, and your own outreach obligations.

The actor does not bypass authentication, paywalls, form protections, or private contact reveal flows.

### Related Actors

Related supplier and lead-generation workflows from automation-lab:

- [Alibaba Supplier Scraper](https://apify.com/automation-lab/alibaba-supplier-scraper) for marketplace supplier discovery.
- [Made-in-China Suppliers Scraper](https://apify.com/automation-lab/madeinchina-suppliers-scraper) for China-focused manufacturer research.
- [ExportersIndia Suppliers Scraper](https://apify.com/automation-lab/exportersindia-suppliers-scraper) for India-focused supplier lists.
- [Thomasnet Scraper](https://apify.com/automation-lab/thomasnet-scraper) for industrial supplier discovery in North America.
- [IQS Directory Industrial Supplier Scraper](https://apify.com/automation-lab/iqsdirectory-industrial-supplier-scraper) for industrial directory research.
- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) for local business lead generation.
- [Website Contact Finder](https://apify.com/automation-lab/website-contact-finder) for finding public contact pages and website contact signals.

Combine this dataset with enrichment actors when you need extra company websites, emails, or firmographic fields that are not visible on Europages result pages.

### Field Notes

`sourceType` tells you which input mode produced the row.

`sourceValue` keeps the original category, term, or URL context.

`pageNumber` and `positionOnPage` preserve pagination metadata.

`areaServed` comes from structured data when Europages publishes it.

### Support

If a valid Europages URL returns no results, include the input and run URL when reporting the issue.

If a field is missing for a supplier, verify that Europages shows that field publicly in the result card.

### FAQ

Can it scrape every contact detail from Europages?

No. It exports public text and URLs visible in the initial HTML, not protected contact details hidden behind interactive flows.

Why are some website URLs empty?

Many Europages result cards do not expose an external website link. In those cases the actor keeps the public Europages profile URL.

Can I scrape multiple categories in one run?

Yes. Provide several `startUrls`, `searchTerms`, or `categories`; the actor deduplicates suppliers by `profileUrl` during the run.

# Actor input Schema

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

Europages category or search result URLs to scrape.

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

Keywords to convert into Europages company search URLs.

## `categories` (type: `array`):

Europages category slugs or names, for example electronics or industrial machinery.

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

Maximum number of supplier rows to save.

## `maxPagesPerSearch` (type: `integer`):

Maximum number of paginated result pages to follow for each source.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed Europages requests.

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

Proxy settings for Europages requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.europages.co.uk/companies/electronics.html"
    }
  ],
  "searchTerms": [
    "electronics"
  ],
  "categories": [
    "electronics"
  ],
  "maxItems": 20,
  "maxPagesPerSearch": 1,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.europages.co.uk/companies/electronics.html"
        }
    ],
    "searchTerms": [
        "electronics"
    ],
    "categories": [
        "electronics"
    ],
    "maxItems": 20,
    "maxPagesPerSearch": 1,
    "maxRequestRetries": 3,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/europages-supplier-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": [{ "url": "https://www.europages.co.uk/companies/electronics.html" }],
    "searchTerms": ["electronics"],
    "categories": ["electronics"],
    "maxItems": 20,
    "maxPagesPerSearch": 1,
    "maxRequestRetries": 3,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/europages-supplier-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": [
    {
      "url": "https://www.europages.co.uk/companies/electronics.html"
    }
  ],
  "searchTerms": [
    "electronics"
  ],
  "categories": [
    "electronics"
  ],
  "maxItems": 20,
  "maxPagesPerSearch": 1,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call automation-lab/europages-supplier-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Europages Supplier Scraper",
        "description": "Extract public Europages supplier leads with company profiles, locations, descriptions, badges, products, and contact entry URLs.",
        "version": "0.1",
        "x-build-id": "HcQRcz2NYNXONVcHZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~europages-supplier-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-europages-supplier-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/automation-lab~europages-supplier-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-europages-supplier-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/automation-lab~europages-supplier-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-europages-supplier-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": "Start URLs",
                        "type": "array",
                        "description": "Europages category or search result URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to convert into Europages company search URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Europages category slugs or names, for example electronics or industrial machinery.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max supplier results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of supplier rows to save.",
                        "default": 20
                    },
                    "maxPagesPerSearch": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of paginated result pages to follow for each source.",
                        "default": 3
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed Europages requests.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings for Europages requests."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```