# Europages Scraper - European B2B Suppliers Data (`studio-amba/europages-scraper`) Actor

Search and extract B2B supplier and company data from Europages, Europe's largest B2B sourcing directory. Get company names, countries, cities, addresses, activities, products, websites, and phone numbers by keyword and country. No API key, no login required.

- **URL**: https://apify.com/studio-amba/europages-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 result scrapeds

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

Learn more: https://docs.apify.com/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 — European B2B Suppliers and Companies

Scrape B2B supplier and company data from [Europages](https://www.europages.com), Europe's largest B2B sourcing directory with millions of listed companies across every industry. Search by product, service, or activity keywords, filter by country, and export clean structured company records with addresses, activities, products, websites, and phone numbers. No login, no cookies, no API key.

### Why use this actor?

Europages is where European buyers find manufacturers, wholesalers, distributors, and service providers. Every profile carries the data a sales or sourcing team actually needs: what the company does, where it sits, how big it is, and how to reach it.

Typical uses:

- **Lead generation** — build supplier or prospect lists for a product niche and country, ready for a CRM import.
- **Supplier sourcing** — find manufacturers and wholesalers for a product you need, compare countries and company sizes.
- **Market research** — count and map suppliers per country for any B2B niche, track how a segment evolves over time.
- **Data enrichment** — match company names to websites, phone numbers, locations, and activity descriptions.

The actor reads the data embedded in the Europages search results pages, so records are complete and consistent. It only returns contact details that companies publish openly on their Europages profiles.

### How to scrape Europages data

1. Open the actor and set a **Search Query** — product, service, or activity keywords such as `packaging`, `steel pipes`, `organic food`, or `injection moulding`. English works best, but Europages matches other languages too.
2. Optionally set a **Country Filter** to a single country, by name or ISO code (`Germany`, `de`, `France`, `Italy`).
3. Set **Max Results** to the number of companies you want (30 companies per results page).
4. Keep the residential proxy prefill and click **Start**.
5. When the run finishes, export the dataset as JSON, CSV, or Excel, or pull it from the Apify API.

The actor paginates through the search results automatically until it reaches your Max Results or runs out of matching companies.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Product, service, or activity keywords (e.g. `packaging`, `steel pipes`). Defaults to `packaging` if empty. |
| `country` | String | No | Only return suppliers from this country. English name or ISO code (`Germany`, `de`, `France`). Empty = all countries. |
| `maxResults` | Integer | No | Maximum number of companies to return (default: 50, max: 2000). |
| `proxyConfiguration` | Object | No | Proxy settings. Residential proxies recommended. |

Example input:

```json
{
    "searchQuery": "packaging",
    "country": "Germany",
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
````

### Output

Each result is one company:

| Field | Type | Example |
|-------|------|---------|
| `companyName` | String | `"ALYA PACKAGING"` |
| `country` | String | `"Turkey"` |
| `countryCode` | String | `"TR"` |
| `city` | String | `"Istanbul"` |
| `address` | String | `"Vizyon Park 5.plaza no:508 29ekim cd."` |
| `postalCode` | String | `"34197"` |
| `activities` | Array | `["production", "wholesaler"]` |
| `products` | Array | `["Printed Apparel Shirt Boxes", "Custom Printed Bottle Boxes"]` |
| `about` | String | `"Alya Packaging, based in Istanbul, brings over 30 years..."` |
| `url` | String | `"https://www.europages.co.uk/ALYA-PACKAGING/00000005424124-761159001.html"` |
| `website` | String | `"https://alyapackaging.com/"` |
| `phone` | String | `"+902126032466"` |
| `email` | String | `null` (only when publicly listed) |
| `employeeCount` | String | `"50-99"` |
| `foundingYear` | Number | `2004` |
| `distributionArea` | String | `"international"` |
| `certificatesCount` | Number | `3` |
| `verifiedSupplier` | Boolean | `true` |
| `logoUrl` | String | `"https://...amazonaws.com/e955c550.gif"` |
| `latitude` / `longitude` | Number | `41.0031073` / `28.8196995` |
| `companyId` | Number | `22159521` |
| `epId` | String | `"00000005424124-761159001"` |
| `searchQuery` | String | `"packaging"` |
| `scrapedAt` | String | `"2026-07-10T09:30:00.000Z"` |

Example output record:

```json
{
    "companyName": "SNI PACKAGING",
    "country": "Turkey",
    "countryCode": "TR",
    "city": "Istanbul",
    "address": "TEKSTILKENT TICARET MERKEZI G2 BLOK KAPI 75, Esenler",
    "postalCode": "34235",
    "activities": ["wholesaler", "customer specific manufacturing", "production"],
    "products": ["Eco-Friendly Flat Handle Paper Bags", "Kraft SOS Bags"],
    "about": "Founded in 2004, SNI Pack is a leading manufacturer of paper and cardboard packaging products...",
    "url": "https://www.europages.co.uk/SNI-PACKAGING/00000005473409-001.html",
    "website": "https://www.snipack.com/",
    "phone": "+902126032466",
    "email": null,
    "employeeCount": "50-99",
    "foundingYear": 2004,
    "distributionArea": "international",
    "certificatesCount": 3,
    "verifiedSupplier": false,
    "logoUrl": "https://wlw-1-company-facts-media.s3.eu-central-1.amazonaws.com/15632718.gif",
    "latitude": 41.0646744,
    "longitude": 28.8680372,
    "companyId": 22210933,
    "epId": "00000005473409-001",
    "searchQuery": "packaging",
    "scrapedAt": "2026-07-10T09:30:00.000Z"
}
```

### Country filter values

Use the English country name or the ISO 3166-1 alpha-2 code. Both of these work: `Germany` or `de`, `France` or `fr`, `United Kingdom` or `gb`/`uk`, `Czech Republic` or `cz`. Europages covers all EU countries plus the wider region (Switzerland, Norway, Turkey, Ukraine, Serbia) and major non-European supplier countries (China, India, United States).

### Cost estimate

The actor reads 30 companies per page request, so runs are cheap: about 1,000 companies per two dozen page fetches. A typical 100-result run finishes in under a minute on the default settings. Expect several thousand results per $1 of Apify platform credits, plus the per-result actor fee.

### Limitations and notes

- Contact details (phone, email, website) are only returned when the company publishes them openly on its Europages profile. Email addresses are rarely public; phone numbers and websites usually are.
- Results follow the Europages relevance ranking for your keywords. Verified (paying) Europages customers rank higher, exactly as on the website.
- A single query can page through up to roughly 2,000 companies. For bigger extractions, split the work into multiple runs with country filters.
- The English-language catalogue is served from the `europages.co.uk` domain; profile URLs in the output point there. The same companies are on every Europages locale domain.
- The actor does not log in, does not bypass any access controls, and only collects data that is publicly visible on the site.

### Feedback

If a field comes back empty that you can see on the website, or you need an extra filter (region, city, supplier type), open an issue on the actor page and it will be looked at quickly.

# Actor input Schema

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

Product, service, or activity keywords to search for (e.g. 'packaging', 'steel pipes', 'organic food', 'injection moulding'). Company names also work.

## `country` (type: `string`):

Optional. Only return suppliers from this country. Use the English country name or ISO code (e.g. 'Germany', 'de', 'France', 'Italy', 'united kingdom'). Leave empty for all countries.

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

Maximum number of companies to return. Europages serves 30 companies per results page.

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

Proxy settings. Residential proxies recommended for reliable access.

## Actor input object example

```json
{
  "searchQuery": "packaging",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQuery": "packaging",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Europages Scraper - European B2B Suppliers Data",
        "description": "Search and extract B2B supplier and company data from Europages, Europe's largest B2B sourcing directory. Get company names, countries, cities, addresses, activities, products, websites, and phone numbers by keyword and country. No API key, no login required.",
        "version": "0.1",
        "x-build-id": "UMopJa1gxmdGisLX0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~europages-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-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/studio-amba~europages-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-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/studio-amba~europages-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Product, service, or activity keywords to search for (e.g. 'packaging', 'steel pipes', 'organic food', 'injection moulding'). Company names also work.",
                        "default": "packaging"
                    },
                    "country": {
                        "title": "Country Filter",
                        "type": "string",
                        "description": "Optional. Only return suppliers from this country. Use the English country name or ISO code (e.g. 'Germany', 'de', 'France', 'Italy', 'united kingdom'). Leave empty for all countries."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of companies to return. Europages serves 30 companies per results page.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies recommended for reliable access.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
