# Europages Scraper(Cheap) (`data_api/europages-scraper-cheap`) 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/data\_api/europages-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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

![Europages Scraper](cover.jpg)

Europages lists millions of B2B suppliers across Europe, but the site gives you no way to pull that into a spreadsheet. You end up copying company names, phone numbers, and websites by hand, one profile at a time. This scraper does the legwork for you: type in a search phrase, and it walks the result pages and hands back one tidy row per company, with the contact details, address, coordinates, supplier role, and product tags already pulled apart into separate fields. Run a single keyword or a whole list of them in one go.

### What you get

Each company becomes a single row with a steady set of columns, so your export drops straight into a sheet or CRM. Fields you don't have data for are left out rather than padded with empties. The data splits into a few natural groups:

- **Identity** — `businessName`, `businessSummary`, `directoryId`, `profileUrl`
- **Contact and location** — `phoneNumber`, `websiteUrl`, `streetAddress`, `cityName`, `postalCode`, `countryCode`, `latitude`, `longitude`
- **Company profile** — `yearFounded`, `staffSize`, `productTotal`, `activityTags`, `supplierRoles`, `membershipTier`, `logoLink`
- **Run metadata** — `collectedAt`

### Quick start

1. Click **Try for free** and open the input form.
2. Type one or more phrases into **Search terms** (for example `packaging machinery`).
3. Set **Results per term** to cap how many companies you pull for each phrase.
4. Press **Start**, then download the dataset as JSON, CSV, Excel, or XML when the run ends.

![How it works](how-it-works.jpg)

### Use cases

- **Lead generation** — build supplier and manufacturer prospect lists across many product categories in one run
- **Market entry** — scope out which European companies operate in a niche before you commit to a region
- **CRM enrichment** — top up your records with phone numbers, websites, coordinates, and founding years
- **Supplier mapping** — see how supplier density breaks down by country or product type
- **Procurement research** — shortlist vendors for a category and compare their listed activities side by side

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchTerms` | array of strings | Yes | Phrases to search on Europages. Each one is queried on its own and its matches are kept separate. |
| `resultsLimit` | integer | No | How many company records to pull per phrase. Default `25` (capped at 1,000 in practice). |
| `timeoutSeconds` | integer | No | Seconds to wait on a single request before giving up. Default `90`; raise it if you see timeout errors. |

#### Example input

```json
{
    "searchTerms": ["industrial valves", "organic cosmetics"],
    "resultsLimit": 25,
    "timeoutSeconds": 90
}
````

### Output

Every company that matches your search becomes one row in the dataset. Values that a company hasn't published are simply absent, so the fields you do get are always real.

#### Example output

```json
{
    "businessName": "Valmont Industrie SAS",
    "businessSummary": "Family-run manufacturer of industrial valves and fittings for the chemical and water-treatment sectors since 1998.",
    "cityName": "Lyon",
    "countryCode": "FR",
    "streetAddress": "14 Rue de la Fonderie",
    "postalCode": "69007",
    "phoneNumber": "+33478920145",
    "websiteUrl": "https://www.valmont-industrie.fr/",
    "logoLink": "https://media.visable.com/company/3f2a91c7-logo.png",
    "latitude": 45.732891,
    "longitude": 4.842217,
    "yearFounded": 1998,
    "staffSize": "11-50",
    "productTotal": 18,
    "profileUrl": "https://www.europages.co.uk/en/company/valmont-industrie-20194471/",
    "directoryId": 2018774,
    "activityTags": ["industrial valves", "pipe fittings", "flow control"],
    "supplierRoles": ["Manufacturer"],
    "membershipTier": "Premium",
    "collectedAt": "2026-06-29T10:00:00+00:00"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `businessName` | string | Name of the company as listed on Europages |
| `businessSummary` | string | Brief self-description of the company's activity |
| `cityName` | string | Town or city where the business is based |
| `countryCode` | string | Two-letter ISO 3166-1 country code, such as FR, DE, or GB |
| `streetAddress` | string | Street name and number of the premises |
| `postalCode` | string | Postal or ZIP code |
| `phoneNumber` | string | Contact phone number from the profile |
| `websiteUrl` | string | Link to the company's own website |
| `logoLink` | string | Direct URL of the company logo image |
| `latitude` | number | Map latitude of the company location |
| `longitude` | number | Map longitude of the company location |
| `yearFounded` | integer | Year the company started trading |
| `staffSize` | string | Headcount band, such as 11-50 or 51-200 |
| `productTotal` | integer | Number of products the company has published |
| `profileUrl` | string | Direct link to the company's Europages profile |
| `directoryId` | integer | Internal Europages identifier for the company |
| `activityTags` | array | Product and activity labels tied to the company |
| `supplierRoles` | array | Supplier role labels, such as Manufacturer or Distributor |
| `membershipTier` | string | The company's Europages subscription level |
| `collectedAt` | string | ISO 8601 timestamp of when the row was gathered |

### Tips for best results

- **Be specific with phrases.** `cnc machining` pulls sharper matches than `manufacturing`, and `solar panel installation` beats a broad `energy`. Tighter phrases give you more relevant companies.
- **Search several phrases at once.** Add all your terms in one run rather than starting separate jobs. Each phrase is searched on its own with its own limit.
- **Cap test runs with `resultsLimit`.** Keep it around 10-25 while you confirm the columns fit your pipeline, then raise it for the full pull.
- **Filter by country afterward.** Every row already carries a `countryCode`, so you can split or filter your dataset by country once it lands in a sheet.
- **Raise `timeoutSeconds` if the log shows timeouts.** Try 120 when the network is slow; the default of 90 covers most searches.

### How can I use Europages company data?

**How can I use the Europages Scraper to build a B2B supplier list?**
Add the product phrases your buyers care about, set a per-term limit, and run it. Each match comes back as one row with the business name, phone, website, and address already separated into fields — so you get a clean prospect list you can import straight into a CRM or outreach tool, no copy-pasting from profile pages.

**How can I find European manufacturers in a specific product category?**
Search the category by name, for example `packaging machinery` or `industrial valves`. The scraper returns every matching company along with its `supplierRoles`, `activityTags`, and location, so you can quickly tell manufacturers apart from distributors and shortlist the ones in the regions you serve.

**How can I export Europages business data to a spreadsheet?**
Run your search, then download the dataset as CSV or Excel from the Apify console. Because every company shares the same column layout — `businessName`, `cityName`, `countryCode`, `websiteUrl`, and the rest — the file opens cleanly in Excel or Google Sheets and is ready to sort, filter, or hand off to your team.

**How can I enrich a CRM with Europages contact details?**
Point the scraper at the categories your accounts fall into and pull the `phoneNumber`, `websiteUrl`, `streetAddress`, and `yearFounded` for each company. Match those rows back to your existing records to fill gaps in contact data and add firmographic context like staff size and supplier role.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

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

One or more phrases to look up on Europages (for example 'industrial valves', 'organic cosmetics', 'packaging machinery'). The actor runs each phrase as its own search and gathers up to the per-term limit.

## `resultsLimit` (type: `integer`):

How many company records to pull for each search phrase. Every phrase is capped at this number on its own.

## `timeoutSeconds` (type: `integer`):

How long to wait on a single request before giving up. Bump it up if timeout errors show in the log.

## Actor input object example

```json
{
  "searchTerms": [
    "industrial valves",
    "organic cosmetics"
  ],
  "resultsLimit": 25,
  "timeoutSeconds": 90
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchTerms": [
        "packaging machinery"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/europages-scraper-cheap").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "searchTerms": ["packaging machinery"] }

# Run the Actor and wait for it to finish
run = client.actor("data_api/europages-scraper-cheap").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "packaging machinery"
  ]
}' |
apify call data_api/europages-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Europages Scraper(Cheap)",
        "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": "ym5qrLdsvYDPaMMux"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~europages-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-europages-scraper-cheap",
                "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/data_api~europages-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-europages-scraper-cheap",
                "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/data_api~europages-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-europages-scraper-cheap",
                "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": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "One or more phrases to look up on Europages (for example 'industrial valves', 'organic cosmetics', 'packaging machinery'). The actor runs each phrase as its own search and gathers up to the per-term limit.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsLimit": {
                        "title": "Results per term",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "How many company records to pull for each search phrase. Every phrase is capped at this number on its own.",
                        "default": 25
                    },
                    "timeoutSeconds": {
                        "title": "Timeout (seconds)",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on a single request before giving up. Bump it up if timeout errors show in the log.",
                        "default": 90
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
