# Europages B2B Supplier Scraper 🏭 (phone, email, address) (`tagadanar/europages-scraper`) Actor

Build B2B lead lists from Europages with company name, phone, website, address, geo, employee count, founding year and VAT ID, plus real emails found on each supplier's own site. Paste a category URL and every page gets followed automatically, at $2 per 1,000 companies.

- **URL**: https://apify.com/tagadanar/europages-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Lead generation, E-commerce, AI
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 company founds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 B2B Supplier Scraper 🏭 (phone, email, address)

**Scrape Europages into a clean B2B supplier list, complete with emails.** Paste a Europages category or listing URL and this actor follows every page, returning each company with its **name, phone, website, postal address, geo, employee count, founding year, VAT ID and industry keywords**. Turn on **email enrichment** and it also visits each supplier's own website to pull **real contact emails**, the field every other Europages scraper is missing. It needs no login, no browser and no API key.

Built for **B2B lead generation, supplier sourcing, procurement research, sales prospecting and AI agents** (REST API + MCP).

### Why this Europages scraper

Europages is a pan-European B2B directory covering millions of suppliers across every industry, which makes it a top source for **European B2B leads**. But the field buyers most want, **email**, is form-gated on Europages, so competing scrapers return phone and address only. This actor closes that gap:

- 📧 **Emails no one else gets**: turn on opt-in enrichment and it reads each company's own website (homepage plus contact, impressum or mentions-légales pages) to extract published contact emails.
- 🏢 Firmographics run deeper too, with employee range, founding year, VAT ID, supplier type and distribution area pulled straight from the page's structured data.
- 💸 It costs a fraction of what others charge: **$2 per 1,000 companies**, versus the category leader's $12.50/1,000, and there's no browser to inflate the compute bill.
- 🚀 Give it one category URL and it crawls the whole thing, following every result page automatically.

### What you can do with it

- Build B2B lead lists by turning any Europages industry or category into a spreadsheet of suppliers with phone, email and website.
- Source and qualify suppliers: filter by country and keyword, then keep only the companies that have a phone number and size them by employee range.
- Enrich a CRM, exporting company name, primary email, VAT ID and address straight to CSV, Excel or JSON.
- Map a market using the geo coordinates and country codes for territory planning and TAM analysis.
- Feed AI agents structured supplier records over REST or MCP, for outreach and research workflows.

### What you get

- ✅ **Contact records**: company name, **phone**, street, postal code, city and country.
- ✅ **Emails** (opt-in), extracted from each company's own website; since Europages form-gates email, this is the only way to get it.
- ✅ **Firmographics**: employee range, founding year, VAT ID, supplier type and distribution area.
- ✅ **Website**, the supplier's own site, with a high fill rate since it's read straight from the page data.
- ✅ **Geo**: latitude and longitude for mapping and territory planning.
- ✅ **Industry keywords**, the activities and products the company declares.
- ✅ Whole-category crawl, with every result page followed via `pg-N` pagination.
- ✅ Filters for phone-only, country (ISO code) and keyword.

### Quick start

```json
{
    "searchUrls": ["https://www.europages.co.uk/companies/packaging.html"],
    "enrichEmails": true,
    "withPhoneOnly": true,
    "countries": ["FR", "DE"],
    "maxResults": 500
}
````

### Output (per company)

```json
{
    "source": "Europages",
    "id": "00000005424124-761159001",
    "url": "https://www.europages.co.uk/ALYA-PACKAGING/00000005424124-761159001.html",
    "name": "ALYA PACKAGING",
    "phone": "+902126032466",
    "hasPhone": true,
    "address": "Vizyon Park 5.plaza no:508 29ekim cd., 34197 Istanbul",
    "streetAddress": "Vizyon Park 5.plaza no:508 29ekim cd.",
    "postalCode": "34197",
    "city": "Istanbul",
    "country": "TR",
    "latitude": 41.0,
    "longitude": 28.9,
    "website": "https://alyapackaging.com",
    "emails": ["info@alyapackaging.com"],
    "primaryEmail": "info@alyapackaging.com",
    "hasEmail": true,
    "employeeCount": "50-99",
    "foundingYear": null,
    "vatId": null,
    "distributionArea": "international",
    "keywords": ["packaging for cosmetics", "printed paper bags"],
    "scrapedAt": "2026-07-05T20:30:00.000Z"
}
```

### Pricing

Pay per event, no subscription:

| Event | Price | When |
|---|---|---|
| Company found | **$2.00 / 1,000** | Per company record returned |
| Email found | **$2.00 / 1,000** | Only when enrichment finds at least one email for a company |

Apify platform usage (compute) is billed separately at platform rates. No proxy is required.

### FAQ

**Can I get supplier emails from Europages?** Europages itself hides email behind a contact form, so no scraper can read it there. This actor goes further: with `enrichEmails` on, it visits each supplier's own website (homepage + contact pages) and extracts published contact emails. Typical hit rate: **around half to two-thirds of companies that have a website.**

**Is the phone real?** Yes, it's the company's published number, read from the profile's structured data.

**How do I target a country or industry?** Paste the relevant Europages category URL and use the `countries` / `keyword` filters.

**How do I export the leads?** Use Apify's dataset export (CSV, Excel or JSON), or call the API directly at `.../dataset/items?format=csv`. `primaryEmail`, `phone` and `website` are ready for a CRM import.

**Does it need a proxy?** No, Europages has no anti-bot. Email enrichment just adds a few light HTTP requests per company to the supplier's own site.

**Is it reliable?** Server-rendered pages with structured data and no anti-bot. Missing fields degrade to `null`, failed pages retry, and a company is never dropped just because its website is down.

**Can I use it with AI agents?** Yes, both REST API and **MCP** are supported.

***

### Something missing?

If you need an extra field, another source, or a different output, open an issue on this Actor and describe it. I read every request and small additions usually ship within days. More data and lead generation Actors are on [my profile](https://apify.com/tagadanar).

*Keywords: europages scraper, b2b supplier scraper, b2b email scraper, supplier email finder, european suppliers database, b2b lead generation, procurement leads, company phone scraper, supplier sourcing, sales prospecting, VAT ID, MCP.*

# Actor input Schema

## `searchUrls` (type: `array`):

Paste one or more Europages <b>category/listing</b> URLs (e.g. <code>https://www.europages.co.uk/companies/packaging.html</code>) or individual <b>company profile</b> URLs. Browse a category on europages and copy the URL — all result pages are followed automatically.

## `enrichEmails` (type: `boolean`):

Europages hides emails behind a contact form — but most suppliers publish one on their <b>own website</b>. When on, the actor visits each company's site (homepage + contact pages, plain HTTP) and extracts contact emails. Adds ~1–4 requests per company; emails found are billed as a separate event.

## `withPhoneOnly` (type: `boolean`):

Keep only companies that expose a phone number.

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

Keep only companies in these countries, by 2-letter ISO code (e.g. <code>FR</code>, <code>DE</code>, <code>IT</code>).

## `keyword` (type: `string`):

Keep only companies whose name, description or keywords contain this text (case-insensitive).

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

Stop after this many company records.

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

Europages has no anti-bot, so a proxy is <b>not required</b>. Enable Apify Proxy only for very large runs.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.europages.co.uk/companies/packaging.html"
  ],
  "enrichEmails": false,
  "withPhoneOnly": false,
  "countries": [],
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `companies` (type: `string`):

One item per company in the default dataset.

# 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 = {
    "searchUrls": [
        "https://www.europages.co.uk/companies/packaging.html"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/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 = {
    "searchUrls": ["https://www.europages.co.uk/companies/packaging.html"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/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 '{
  "searchUrls": [
    "https://www.europages.co.uk/companies/packaging.html"
  ],
  "maxResults": 20
}' |
apify call tagadanar/europages-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Europages B2B Supplier Scraper 🏭 (phone, email, address)",
        "description": "Build B2B lead lists from Europages with company name, phone, website, address, geo, employee count, founding year and VAT ID, plus real emails found on each supplier's own site. Paste a category URL and every page gets followed automatically, at $2 per 1,000 companies.",
        "version": "0.1",
        "x-build-id": "wCbA3j8Bi44HRjhub"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tagadanar~europages-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tagadanar-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/tagadanar~europages-scraper/runs": {
            "post": {
                "operationId": "runs-sync-tagadanar-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/tagadanar~europages-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-tagadanar-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": {
                    "searchUrls": {
                        "title": "Category / listing URLs (europages)",
                        "type": "array",
                        "description": "Paste one or more Europages <b>category/listing</b> URLs (e.g. <code>https://www.europages.co.uk/companies/packaging.html</code>) or individual <b>company profile</b> URLs. Browse a category on europages and copy the URL — all result pages are followed automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "enrichEmails": {
                        "title": "Find emails on company websites",
                        "type": "boolean",
                        "description": "Europages hides emails behind a contact form — but most suppliers publish one on their <b>own website</b>. When on, the actor visits each company's site (homepage + contact pages, plain HTTP) and extracts contact emails. Adds ~1–4 requests per company; emails found are billed as a separate event.",
                        "default": false
                    },
                    "withPhoneOnly": {
                        "title": "Only companies with a phone",
                        "type": "boolean",
                        "description": "Keep only companies that expose a phone number.",
                        "default": false
                    },
                    "countries": {
                        "title": "Countries (ISO codes)",
                        "type": "array",
                        "description": "Keep only companies in these countries, by 2-letter ISO code (e.g. <code>FR</code>, <code>DE</code>, <code>IT</code>).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Keyword filter",
                        "type": "string",
                        "description": "Keep only companies whose name, description or keywords contain this text (case-insensitive)."
                    },
                    "maxResults": {
                        "title": "Max companies",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Stop after this many company records.",
                        "default": 500
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (optional)",
                        "type": "object",
                        "description": "Europages has no anti-bot, so a proxy is <b>not required</b>. Enable Apify Proxy only for very large runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```