# Yell.com Scraper \[$1.2/1K💰] | UK Leads | Emails & Phones (`ahmed_jasarevic/yell-scraper`) Actor

Scrape UK business listings from Yell.com for lead generation: business name, email, phone, website, address, category, rating, reviews and opening hours per listing. Built for UK lead-gen agencies, SMB outreach teams, local SEO auditors and CRM enrichment.

- **URL**: https://apify.com/ahmed\_jasarevic/yell-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.17 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Yell.com Scraper — UK Business Listings, Emails & Phones for Lead Generation

**Extract UK business listings from Yell.com — the UK's No. 1 business directory and the digital successor to Yellow Pages — to build lead-generation lists, enrich CRM data and audit local competitors from ~$1.20 per 1,000 listings.** Each dataset row carries the business name, email, phone, website, address, category, rating, review count and opening hours, ready for lead gen, SMB outreach and local SEO work.

Built for **UK lead-gen agencies, SMB outreach teams, local SEO auditors and CRM enrichment** workflows. Run it on the [Apify platform](https://apify.com) to get API access, scheduling, proxy rotation, monitoring and one-click exports to JSON, CSV, Excel or Google Sheets.

### Main Use Cases

- **UK lead generation** — build targeted prospect lists by trade and town (e.g. plumbers in London) for outbound sales and marketing.
- **SMB outreach & cold email lists** — collect business emails, phone numbers and websites for UK small businesses.
- **Local SEO audits** — benchmark competitors on Yell rating, review count and categories for any UK city or postcode.
- **CRM enrichment** — append verified contact and location data to existing UK business records.
- **Market research & business databases** — map business density by category, town, county or postcode.

### How It Works

Give the actor a business type and a UK location (e.g. `plumbers` + `London`), or paste Yell search-result URLs directly. It crawls Yell's search result pages, handles Yell's Cloudflare Bot Management automatically, and returns one dataset row per business listing. Runs that fit on a single results page (~≤50 listings) finish in about a minute via the Web Unlocker group; larger runs warm up a sticky RESIDENTIAL proxy session once (~2.5 min) and then scrape each page at ~1 second.

The crawler only fetches the pages it still needs — it stops immediately once `maxItems` are collected, so you pay for exactly the listings you ask for.

### Build Business Contact Databases Without an Official Yell API

Yell.com does not offer a public bulk-data or listings API. The official relationship is via Yell Business — a paid marketing service for businesses that advertise, not an API a developer can query. If you need structured UK business contact data — names, emails, phones, websites, ratings — a Yell.com scraper is the practical way to get it programmatically.

### Scrape UK Business Contact Data by Trade and Location

Search by any business type and any UK town, city, postcode or region:

- `plumbers` + `London`
- `electricians` + `Manchester`
- `dentists` + `Birmingham`
- `restaurants` + `Edinburgh`
- `builders` + `SW1A 1AA`

Each search page holds ~50 listings, and the actor follows pagination only until `maxItems` is reached. Results are deduplicated by Yell profile URL (sponsored and organic copies of the same business collapse into one row).

### Extract Business Emails, Phones and Opening Hours from Profiles

With detail enrichment ON (the default), after scraping each listing's basic fields the actor fetches its Yell business profile page and extracts a richer set of data: **business description, all categories, opening hours by day, social links (Facebook, X, Instagram…), email and the Yell Verified badge** at ~1 second per listing.

Detail enrichment is only available in warm-up mode, so single-page (≤~50 listing) runs return the core listing fields — name, phone, website, address, category, rating, reviews, opening hours — plus the extra profile fields automatically when the run exceeds one page of results.

### Input

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `keywords` | string | No\* | `plumbers` | Business type / trade to search for, e.g. `plumbers`, `dentists`, `carpenters`. Ignored when `startUrls` is provided. |
| `location` | string | No\* | `London` | UK town, city, postcode or region, e.g. `London`, `Manchester`, `SW1A 1AA`. Ignored when `startUrls` is provided. |
| `startUrls` | array | No | — | Direct Yell.com search-result URLs to scrape instead of keywords + location, e.g. `https://www.yell.com/ucs/UcsSearchAction.do?keywords=plumbers&location=london`. Overrides `keywords`/`location`. |
| `maxItems` | integer | No | `50` | Max listings to extract. The crawler stops as soon as this many are collected — no extra pages are fetched. |
| `useWarmup` | boolean | No | auto | AUTO (leave empty): uses browser warm-up only when the run needs more than one results page (>~50 listings) — solves Cloudflare once in a real browser on a sticky RESIDENTIAL IP (~2.5 min), then scrapes at ~1s per page. Small runs skip warm-up and use Web Unlocker (~1 min). Set `true` to force warm-up, `false` to always use Web Unlocker. |
| `scrapeDetails` | boolean | No | `true` | Business profile enrichment: after each listing, fetch its Yell profile page for description, all categories, opening hours by day, social links, email and the Verified badge (~1s per listing, capped at ~15 profile fetches per warm-up session before Yell rate-limits the IP — the overflow keeps scraping with plain listing fields). |
| `proxyConfiguration` | object | No | Apify proxy + `UNBLOCKER` | Proxy picker: `useApifyProxy`, `apifyProxyGroups`, `proxyUrls`. In warm-up mode the actor pins a sticky RESIDENTIAL session automatically and ignores advanced groups. |

\* Provide either `keywords` + `location`, **or** `startUrls`. If neither is set, the run fails with `Provide either "keywords" + "location", or "startUrls".`

Example input:

```json
{
    "keywords": "plumbers",
    "location": "London",
    "maxItems": 50,
    "useWarmup": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["UNBLOCKER"]
    }
}
```

### Output

Each Yell.com business listing becomes one dataset row. With detail enrichment ON, up to 17 fields per row:

| Field | Description |
| --- | --- |
| `name` | Business name. |
| `url` | Yell business profile URL. |
| `category` | Primary business classification. |
| `categories` | All categories listed for the business (array, from the profile page). |
| `phone` | Contact phone number(s). |
| `website` | Business website (when listed). |
| `email` | E-mail address (from the business profile page, when visible). |
| `address` | Full street address. |
| `rating` | Average star rating (e.g. `4.5`). |
| `reviews` | Number of reviews. |
| `openingHours` | Current opening status / hours (from the search capsule). |
| `hoursByDay` | Opening hours split by weekday (object, from the business profile page). |
| `description` | Business description / about blurb (from the business profile page). |
| `socialLinks` | Social-media links found on the business profile page (Facebook, X, Instagram…). |
| `verified` | `true` if Yell marks the business as Verified. |
| `searchKeyword` | The keyword used for this run. |
| `searchLocation` | The location used for this run. |

Example output row:

```json
{
    "name": "Bandera Ltd",
    "url": "https://www.yell.com/biz/bandera-ltd-manchester-5857009/",
    "category": "Restaurants",
    "phone": "0161 833 9019",
    "website": "http://www.harpersmanchester.co.uk",
    "address": "2 Ridgefield, Manchester, M2 6EQ",
    "rating": "4.0",
    "reviews": "1",
    "openingHours": "Open now · Closes 11:00 pm",
    "searchKeyword": "plumbers",
    "searchLocation": "London"
}
```

You can download the dataset in JSON, HTML, CSV, Excel or XML, or push it on to a database, Google Sheets or a webhook via the Apify API.

### How Much Does It Cost to Scrape Yell.com?

The actor is **pay-per-event**: a fixed $0.00005 per GB of memory when a run starts, and **$0.0012 per listing result** (lower tiers may pay slightly less per result). In practice:

- A single-page lookup of **50 listings ≈ $0.06**, finished in about a minute.
- A **1,000-listing pull ≈ $1.20** plus a negligible start fee, using the browser warm-up path (~2.5 min warm-up + ~1s per page).

The crawler fetches only what it needs and stops at `maxItems`, so costs scale linearly with the number of listings you actually collect. Free plans get a capped preview of **10 listings**; paying users get unlimited runs (subject to `maxItems`).

Two proxy modes are built in and automatic:

- **Web Unlocker (small runs):** when the result set fits on one results page, each page is solved server-side (~20–45s) and the run finishes in about a minute. Keep the proxy configuration ON.
- **Browser warm-up (auto for large runs):** a real headed Chromium solves Cloudflare **once** on a sticky **RESIDENTIAL** Apify proxy session (~2.5 min), then every page is served from inside that solved tab at ~1s each — far cheaper than per-page unlocks. This requires the **RESIDENTIAL** proxy group on your Apify plan; if your plan doesn't include it, set `useWarmup: false` and the actor falls back to Web Unlocker automatically.

### Integrations & Automation

- **Apify API & SDKs** — run the actor from JavaScript (`apify-client`), Python, or any HTTP client; pull results as JSON/CSV/Excel.
- **Schedule it** — use Apify's built-in scheduler (daily or weekly) to keep UK lead lists and review/rating data fresh. This actor is a natural fit for recurring monitoring: ratings, review counts, opening hours and Verified badges change over time.
- **Webhooks** — push completed-run datasets straight into your own system.
- **Zapier / Make / Google Sheets** — connect the dataset to downstream tools through Apify's standard integrations.
- **MCP servers** — expose this actor (or any Apify actor) to Claude, Cursor or other MCP clients via the [Apify MCP server](https://apify.com/apify/actors-mcp-server), so an AI agent can pull UK Yell.com data on demand.

Recommended schedule: weekly for lead lists and prospect databases; monthly for market research and local SEO benchmarking.

### Related Actors

- [**Yellow Pages US Scraper**](https://apify.com/trudax/yellow-pages-us-scraper) — the US counterpart of this actor: addresses, phone numbers, categories and names from YellowPages.com.
- [**Thomson Local Scraper**](https://apify.com/dominic-quaiser/thomson-local-scraper) — another of the UK's largest business directories (Thomson Local, 2.6M+ listings).
- [**Yellow Pages Scraper**](https://apify.com/automation-lab/yellowpages-scraper) — generic Yellow Pages business listings: names, phones, addresses, ratings and reviews.
- [**FreeIndex Scraper - UK Business Directory**](https://apify.com/crawlerbros/freeindex-scraper) — UK directory data with 450,000+ reviews, by category and city.
- [**Yell Business Details Scraper**](https://apify.com/ecomscrape/yell-business-details-scraper) — complementary Yell actor for pulling full data from a list of existing Yell profile URLs.

### FAQ

#### Why use this actor instead of the official Yell API?

There is no official Yell listings API for developers — Yell's data products are marketing services for advertisers, not programmatic data access. Scraping Yell.com with a purpose-built actor is the standard way to get structured UK business contact data, and this actor removes the hard part (Cloudflare Bot Management) automatically.

#### Can you scrape Yell.com? Is it legal?

Scraping publicly available business directory data is common practice and, for public-facing business information like name, phone and address, generally treated the same as accessing any public website (the reasoning applied in *hiQ v. LinkedIn*). This actor only accesses publicly available Yell.com pages — no login bypass, no CAPTCHA farms. You are responsible for complying with Yell.com's Terms of Service and applicable data-protection law (e.g. UK GDPR) when using the data, and for how you use contact details (see the Legal & Compliance Disclaimer below).

#### Why does Yell.com limit each search to about 10 pages?

Yell caps on-site pagination per search — third-party Yell scrapers consistently report a ~10-page / few-hundred-results ceiling per keyword+location search. To go deeper, run the same category for multiple towns and postcodes, or use `startUrls` to target specific category pages. This actor pages through whatever Yell returns until `maxItems` is reached.

#### Is Yell still Yellow Pages?

Yes — Yell.com is the digital successor of the Yellow Pages directory. Yellow Pages ended printed production in 2017 and fully moved online as Yell, which is why "Yellow Pages UK" searches resolve to yell.com today.

#### What data does this actor extract from Yell.com?

Business name, Yell profile URL, primary category and all categories, phone, website, email (when published), full address, star rating, review count, current opening status, opening hours by day, business description, social links and the Yell Verified badge — plus the search keyword and location used.

#### What is an alternative to Yell.com for UK business data?

Thomson Local and FreeIndex are the other big UK directories and have scrapers of their own (see Related Actors); Google Maps data is a strong complementary source; Yelp UK covers consumer categories. Yell.com remains the largest UK business directory, so it is usually the best single source for UK lead lists. The actor accepts direct `startUrls`, so you can scrape Yell category pages precisely for any trade or town.

#### What is the best way to build a list of UK tradesmen for cold outreach?

Search by trade and town — e.g. `plumbers` + `Manchester`, `electricians` + `Birmingham` — with `scrapeDetails` ON to get email, phone, website and social links, then export to CSV/Excel and load into your outreach tool. Running the same trade across multiple towns (or every postcode district) builds a national tradesmen dataset; see the UK Tradesmen Contact Data task.

#### How do I get UK business emails and phone numbers?

Yell only shows email addresses on business profile pages, and this actor fetches those pages when `scrapeDetails` is ON, extracting `email`, `socialLinks`, `hoursByDay` and the `verified` badge alongside the listing fields. Some businesses simply don't publish an email — in that case the field is empty, and the phone number is the contact to use.

#### Is Yell.com data compliant with GDPR?

Yell.com listings are publicly available business information, and business contact details published for commercial purposes are handled differently from personal data in practice. This actor does not collect personal consumer data. You must still comply with UK GDPR and the Privacy and Electronic Communications Regulations (PECR) when storing data and when using email/phone details for marketing — the same obligations apply to any lead list you buy or build.

### SEO Keywords

yell.com scraper, scrape yell.com, yell.com api, yell business data, uk business directory, yellow pages uk, uk business leads, uk b2b leads, uk business contact data, local seo audit, local seo competitor analysis, uk lead generation, sMB outreach list, cold email list uk, uk tradesmen data, tradesman leads uk, business email extraction, crm enrichment uk, business rating data, yell.com alternatives, plumbers in london data, uk business database, reviews and ratings monitoring, yell data export, business directory scraping uk

### For AI Agents & LLM Apps

This actor is fully callable via the [Apify MCP server](https://apify.com/apify/actors-mcp-server) and the Apify REST API. Use it whenever a task needs UK business contact data from Yell.com — lead generation, prospect lists, local competitor benchmarking, CRM enrichment or market research.

**Purpose:** returns Yell.com business listings for a UK trade + location (or a set of Yell search URLs) — each row is one business with contact, category, rating, review and opening-hours data.

**Minimal working input:**

```json
{ "keywords": "plumbers", "location": "London", "maxItems": 10 }
```

**Alternative mode — start URLs (takes priority when present):**

```json
{ "startUrls": [{ "url": "https://www.yell.com/ucs/UcsSearchAction.do?keywords=plumbers&location=london" }], "maxItems": 10 }
```

**Output fields (dataset):** `name`, `url`, `category`, `categories`, `phone`, `website`, `email`, `address`, `rating`, `reviews`, `openingHours`, `hoursByDay`, `description`, `socialLinks`, `verified`, `searchKeyword`, `searchLocation`.

**Behaviors an agent should know:**

- `startUrls` **overrides** `keywords`/`location` — if `startUrls` is non-empty, search keywords are ignored. If `startUrls` is empty and either `keywords` or `location` is missing, the run fails with a clear error.
- `maxItems` is the price control: the run stops the moment that many listings are collected, so no extra pages are billed. Default `50`. (`maxResults` is accepted as a legacy alias.)
- `scrapeDetails` defaults to `true`: it adds ~1s per listing to fetch the Yell profile page and populate `email`, `socialLinks`, `hoursByDay`, `categories` and `verified`. Detail fetches are capped at ~15 per warm-up session — overflow rows still contain every listing-level field.
- `useWarmup`: leave unset for auto. Runs >~50 listings trigger a one-time browser warm-up (~2.5 min) that requires the `RESIDENTIAL` proxy group on the Apify plan; if the plan lacks it or you set `false`, the actor uses the `UNBLOCKER` Web Unlocker group instead (slower per page, no residential requirement).
- Some fields are legitimately empty — not every listing publishes an email, website or phone number. Check `website`/`phone` presence rather than treating empties as errors.

**Billing model:** pay-per-event. $0.00005 per GB at run start + **$0.0012 per listing result** returned to the dataset (~$1.20 per 1,000 listings). Keep `maxItems` tight for exploratory runs.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Yell Group Limited** or Yell.com.

The actor accesses only **publicly available Yell.com pages** — it does not bypass any login or paywall. It automatically handles Yell.com's Cloudflare bot challenge on public pages, which is standard automated-access behaviour; users remain responsible for how they use the extracted data.

Because the output can include business **email addresses and phone numbers**, do not use this data for unsolicited commercial outreach in violation of applicable law (e.g. CAN-SPAM, UK PECR, TCPA), and store data in line with UK GDPR (and GDPR/CCPA where the data relates to individuals). This section is factual disclosure, not legal advice — consult a professional for your specific use case.

# Actor input Schema

## `keywords` (type: `string`):

What to search for, e.g. "plumbers", "dentists", "carpenters". Leave empty if you provide startUrls.

## `location` (type: `string`):

UK town, city, postcode or region, e.g. "London", "Manchester", "SW1A 1AA". Leave empty if you provide startUrls.

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

Optional: direct Yell.com search result URLs to scrape instead of keywords+location. Example: https://www.yell.com/ucs/UcsSearchAction.do?keywords=plumbers\&location=london

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

Maximum number of business listings to extract. The Actor stops crawling as soon as this many listings are collected.

## `useWarmup` (type: `boolean`):

AUTO (leave empty): warm up is only used when the run needs more than one results page (over ~50 listings), where solving Cloudflare once in a real browser (~2.5 min) then scraping each page at ~1s is far faster and cheaper than per-page Web Unlocker solves. For result sets that fit on a single page the Actor skips the warm-up and uses Web Unlocker directly, finishing in ~1 minute. Set ON to force browser warm-up even for small runs, or OFF to always use Web Unlocker. Requires the RESIDENTIAL proxy group to hold a sticky IP for the run; if a forced warm-up fails the Actor falls back to Web Unlocker automatically.

## `scrapeDetails` (type: `boolean`):

ON (default): after scraping each listing's basic fields from search results, the Actor also fetches its Yell business profile page to extract a richer set of data: description, all categories, opening hours by day, social links, email and the 'Verified' badge. The extra fetch is ~1 s per listing (still served through the solved warm-up tab) and typically adds only a few seconds to the run. Turn OFF for slightly faster runs when you only need name / phone / website / address.

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

Select proxies to be used by your crawler. Yell.com is protected by Cloudflare Bot Management, so keep the proxy ON. In warmup mode the Actor pins a RESIDENTIAL sticky session automatically and ignores advanced groups. In Unblocker mode (warmup disabled), the Web Unlocker group (UNBLOCKER) solves each challenge server-side.

## Actor input object example

```json
{
  "keywords": "plumbers",
  "location": "London",
  "maxItems": 50,
  "scrapeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": "plumbers",
    "location": "London",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "UNBLOCKER"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/yell-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 = {
    "keywords": "plumbers",
    "location": "London",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["UNBLOCKER"],
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "keywords": "plumbers",
  "location": "London",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ]
  }
}' |
apify call ahmed_jasarevic/yell-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/yell-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/TeNkFDXdZyxJvi5CM/builds/GiTYNa4D8aa64BaCt/openapi.json