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

Europages Business Directory Scraper that extracts contact details, addresses, and business profiles from Europe's largest B2B marketplace by keyword, so you can build targeted prospect lists and find suppliers without manual research.

- **URL**: https://apify.com/kawsar/europages-scraper.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (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 $3.99 / 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.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

Search Europages by keyword and pull company profiles into a clean, structured dataset. Names, addresses, phone numbers, websites, founding years, employee counts, coordinates, supplier types, and product keywords — one row per company, ready to use.

### What it does

Europages is one of Europe's largest B2B directories, listing several million companies across 26 countries. This actor searches it by keyword, pages through the results automatically, and pushes each company record to your dataset as it goes. Each page returns 30 companies; the actor keeps paging until it hits your per-keyword limit or runs out of results.

You can run multiple keywords in a single job. Each keyword gets its own independent search — so if you add three keywords at 100 results each, you get up to 300 records total, all in one run.

### How it works

The actor fetches Europages search result pages and parses the structured company data embedded in each page's server-side rendered state. No scraping tricks, no browser automation — the data comes directly from the page payload, which means it's fast and reliable.

Each page is fetched with built-in bypass infrastructure to handle anti-bot measures. If a page returns an incomplete response, the actor retries up to 3 times before moving on.

### Input

| Field | Required | Default | Description |
|---|---|---|---|
| `searchQueries` | Yes | — | One or more keywords to search (e.g. `embroidery`, `solar panels`, `steel pipes`) |
| `maxItems` | No | 100 | Max company records to collect **per keyword** (max 1,000) |
| `requestTimeoutSecs` | No | 60 | Per-request timeout in seconds — raise to 90 or 120 if you see timeout errors |

#### Example input

```json
{
  "searchQueries": ["embroidery", "workwear", "textile printing"],
  "maxItems": 200
}
````

### Output

Each dataset record is one company. Fields are omitted when the data is not publicly available rather than returned as null.

| Field | Type | Description |
|---|---|---|
| `companyName` | string | Company name |
| `companyBio` | string | Short description from the company profile |
| `city` | string | City |
| `countryCode` | string | ISO country code (e.g. `FR`, `DE`, `IT`) |
| `street` | string | Street address |
| `postalCode` | string | Postal / zip code |
| `phoneNumber` | string | Phone number |
| `website` | string | Company website |
| `logoUrl` | string | Logo image URL |
| `latitude` | number | Geographic latitude |
| `longitude` | number | Geographic longitude |
| `foundingYear` | integer | Year the company was founded |
| `employeeCount` | string | Headcount range (e.g. `11-50`, `51-200`) |
| `productCount` | integer | Number of products listed on Europages |
| `europagesUrl` | string | Direct link to the company's Europages profile |
| `europagesId` | integer | Internal Europages company ID |
| `keywords` | array | Product and activity keywords from the profile |
| `supplierTypes` | array | Supplier labels (e.g. `Manufacturer`, `Distributor`) |
| `packageTier` | string | Europages membership tier — omitted for free listings |
| `scrapedAt` | string | ISO 8601 timestamp of when the record was collected |

#### Example output record

```json
{
  "companyName": "UNITON",
  "companyBio": "Since 2001, UNITON has been operating its various branches of activity in the European market, specialising in embroidery and related textile services.",
  "city": "Beaurepaire",
  "countryCode": "FR",
  "street": "Chemin du Pied Menu, ZI Les Fromentaux",
  "postalCode": "38270",
  "phoneNumber": "+33474482814",
  "website": "http://www.uniton.fr/",
  "logoUrl": "https://media.visable.com/company/9d8740d7-...",
  "latitude": 45.324625,
  "longitude": 5.052226,
  "foundingYear": 2001,
  "employeeCount": "5-9",
  "productCount": 10,
  "europagesUrl": "https://www.europages.co.uk/en/company/uniton-20160084/",
  "europagesId": 1344161,
  "keywords": ["embroidery", "textiles", "workwear"],
  "supplierTypes": ["distribution"],
  "scrapedAt": "2026-04-29T10:00:00+00:00"
}
```

### Output format and export

Results are stored in an Apify dataset and available in multiple formats from the Apify console:

- **JSON** — default, one object per record
- **CSV** — flat spreadsheet, opens directly in Excel or Google Sheets
- **XLSX** — Excel format
- **JSONL** — one JSON object per line, useful for streaming pipelines

Use the Apify API to fetch results programmatically or connect via Zapier, Make, or any webhook-based integration.

### Performance

| Metric | Value |
|---|---|
| Results per page | 30 companies |
| Retries per page | Up to 3 on empty response |
| Max results per keyword | 1,000 |
| Actor memory | 512 MB |
| Actor timeout | 1 hour |

Speed depends on network latency and Europages server response time. Most searches collect 30 results in 3–6 seconds per page. A full run of 1,000 results across 34 pages typically takes 3–8 minutes.

### Good use cases

- Building prospect lists of suppliers or manufacturers across multiple product categories in one run
- Finding European companies in a niche before entering a new market
- Enriching a CRM with contact data, coordinates, and founding years
- Mapping supplier density by country or product type
- Monitoring which companies list a particular product or service over time

### Limitations

- **Max 1,000 results per keyword.** Europages limits how deep you can paginate. For very broad keywords that match tens of thousands of companies, narrow your search term or split by region using separate keyword runs.
- **Contact data varies.** Phone numbers are only shown when the company has chosen to make them public.
- **Keyword matching is Europages' own.** The actor collects whatever Europages returns for a given search term — it does not apply additional filtering.
- **Free listings have no package tier.** The `packageTier` field only appears for companies on paid Europages plans.

### Tips

**Be specific with keywords.** `cnc machining` returns sharper results than `manufacturing`. `solar panel installation` beats `energy`. The more precise the term, the more relevant the companies.

**Use multiple keywords in one job.** Instead of running three separate jobs, add all your terms at once. Each runs independently with its own result limit.

**Combine with country targeting.** Europages search results already include a `countryCode` field on every record. After collection, filter your dataset by country in a spreadsheet or downstream pipeline.

**Raise the timeout if needed.** If you see timeout errors, set `requestTimeoutSecs` to 90 or 120. The default of 60 seconds covers most searches.

# Actor input Schema

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

One or more keywords to search for on Europages (e.g. 'embroidery', 'steel pipes', 'solar panels'). The actor runs a separate search for each keyword and collects up to Max items per keyword.

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

Maximum number of company records to extract per keyword. Each keyword runs independently up to this limit.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds. Increase this if you see timeout errors.

## Actor input object example

```json
{
  "searchQueries": [
    "embroidery",
    "solar panels"
  ],
  "maxItems": 100,
  "requestTimeoutSecs": 60
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("kawsar/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 '{}' |
apify call kawsar/europages-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Europages Scraper",
        "description": "Europages Business Directory Scraper that extracts contact details, addresses, and business profiles from Europe's largest B2B marketplace by keyword, so you can build targeted prospect lists and find suppliers without manual research.",
        "version": "0.0",
        "x-build-id": "jegxr0zFpa7lPMfWD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~europages-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-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/kawsar~europages-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-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/kawsar~europages-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-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",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "One or more keywords to search for on Europages (e.g. 'embroidery', 'steel pipes', 'solar panels'). The actor runs a separate search for each keyword and collects up to Max items per keyword.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items per keyword",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of company records to extract per keyword. Each keyword runs independently up to this limit.",
                        "default": 100
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds. Increase this if you see timeout errors.",
                        "default": 60
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```