# uSwitch Scraper - UK Broadband Deals Comparison (`crawlerbros/uswitch-scraper`) Actor

Scrape uSwitch.com for UK broadband deals - standard broadband, cheapest broadband, and mobile broadband. Extract product name, provider, pricing, speed, contract length, features, ratings, and apply URLs for every listed deal.

- **URL**: https://apify.com/crawlerbros/uswitch-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

## uSwitch Scraper

Scrape **uSwitch.com** — the UK's leading utility comparison site — for the latest broadband and mobile broadband deals. Extract structured deal data including provider, pricing, speed, contract length, features, and direct apply links.

### What it does

uSwitch Scraper retrieves publicly available deal listings from uSwitch without requiring any account, API key, or paid proxy. It parses the deal data embedded directly in the page HTML and returns clean, structured records ready for analysis.

### Use Cases

- Price monitoring for UK broadband and mobile broadband deals
- Market research on UK telecoms providers
- Lead generation for comparison or affiliate sites
- Competitive intelligence on provider pricing and contract terms
- Building datasets of UK broadband product offerings

### Input

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `mode` | string (select) | Category to scrape | `broadband` |
| `maxItems` | integer | Maximum deals to return (1–100) | `20` |

#### Mode Options

| Value | Description |
|-------|-------------|
| `broadband` | Top broadband deals (fibre, cable, ADSL) |
| `cheapBroadband` | Budget and cheap broadband deals |
| `mobileBroadband` | 4G/5G mobile broadband dongles and SIMs |

Car insurance and home insurance are **not** supported — uSwitch requires user registration details and a postcode before showing any comparison results for those categories, so there is no public homepage/deals page to scrape (see Limitations below).

#### Example Input

```json
{
  "mode": "broadband",
  "maxItems": 20
}
````

### Output

Each record represents one deal listing on uSwitch.

| Field | Type | Description |
|-------|------|-------------|
| `productName` | string | Full product/deal name (e.g. "Virgin Media Gig1 Fibre broadband") |
| `provider` | string | Provider/supplier name (e.g. "Virgin Media", "BT", "Sky") |
| `category` | string | Deal category (e.g. "Broadband", "Cheap Broadband", "Mobile Broadband") |
| `dealId` | string | uSwitch internal deal identifier |
| `monthlyPrice` | number | Monthly cost in GBP |
| `totalContractCost` | number | Total cost over full contract period (GBP) |
| `upfrontCost` | number | Upfront/one-off cost in GBP (0 when there is none) |
| `contractLength` | integer | Contract duration in months |
| `contractLengthFormatted` | string | Human-readable contract length (e.g. "24 month contract") |
| `downloadSpeed` | integer | Download speed in Mbps (broadband only) |
| `uploadSpeed` | integer | Upload speed in Mbps (broadband only) |
| `downloadSpeedUnit` | string | Speed unit (typically "Mbps") |
| `features` | array | Promotional features and USPs (e.g. "£145 bill credit") |
| `productHighlights` | array | Product highlight callouts (e.g. "Free installation") |
| `providerTrustScore` | number | Trustpilot rating for the provider |
| `providerTrustReviews` | integer | Number of Trustpilot reviews |
| `providerLogo` | string | Provider logo image URL |
| `providerPhone` | string | Provider customer service phone number (when published) |
| `priceRiseNote` | string | Human-readable disclosure of scheduled in-contract price rises |
| `averageMonthlyCost` | number | Average monthly cost over the life of the contract, accounting for any scheduled price rises |
| `averageMonthlyCostStandard` | number | Standard (non-promotional) average monthly cost over the contract |
| `hasDiscountPeriod` | boolean | Whether the deal has an introductory discount period |
| `hasPriceFreeze` | boolean | Whether the price is frozen for the contract term |
| `isFibre` | boolean | Whether the connection is fibre |
| `includesNetflix` | boolean | Whether the deal bundles a Netflix subscription |
| `includesTvChannels` | boolean | Whether the deal bundles TV channels |
| `tvChannelCount` | integer | Number of TV channels included (TV bundles only) |
| `isCashbackDeal` | boolean | Whether the deal includes a cashback offer |
| `isSponsored` | boolean | Whether the deal is a sponsored placement |
| `isExclusive` | boolean | Whether the deal is a uSwitch exclusive |
| `isEndingSoon` | boolean | Whether the deal is flagged as ending soon |
| `dealExpiresAt` | string | Deal offer expiry date/time, as published by uSwitch |
| `applyUrl` | string | Direct URL to apply for or view the deal |
| `sourceUrl` | string | uSwitch page URL where the deal was found |
| `scrapedAt` | string | ISO 8601 timestamp of when the record was scraped |
| `recordType` | string | Always `"deal"` |

#### Example Output

```json
{
  "productName": "Virgin Media Gig1 Fibre broadband",
  "provider": "Virgin Media",
  "category": "Broadband",
  "dealId": "470406-3591855585",
  "monthlyPrice": 25.99,
  "totalContractCost": 695.76,
  "contractLength": 24,
  "contractLengthFormatted": "24 month contract",
  "downloadSpeed": 1000,
  "uploadSpeed": 104,
  "downloadSpeedUnit": "Mbps",
  "features": ["£145 bill credit"],
  "providerTrustScore": 1.5,
  "providerTrustReviews": 105081,
  "isSponsored": false,
  "applyUrl": "https://www.uswitch.com/clk/470406/...",
  "sourceUrl": "https://www.uswitch.com/broadband/",
  "scrapedAt": "2026-06-30T10:00:00+00:00",
  "recordType": "deal"
}
```

### Limitations

- uSwitch deals for `broadband` results pages require a valid UK postcode — without one, the results page returns empty. The scraper uses the category homepage which always shows top 20 deals.
- Energy tariff comparison (`gas-electricity`) requires a postcode and usage data before deals load — not currently supported.
- Car insurance and home insurance require user registration details and a postcode before uSwitch shows any comparison results — there is no public homepage/deals page for these categories, so they are not supported by this actor.
- Deal counts are typically 10–20 per page for homepage views.

### Data Source

Data is scraped from [uswitch.com](https://www.uswitch.com) — a publicly accessible UK utility comparison site. No login, API key, or paid proxy is required.

### FAQs

**Do I need a UK proxy?**
No. uSwitch pages are accessible from international IP addresses.

**Does this need residential proxies?**
No. uSwitch serves its comparison pages freely and Apify's standard AUTO datacenter proxy works fine.

**How fresh is the data?**
uSwitch updates its deals in near real-time. Each scraper run fetches fresh data.

**Can I scrape deals for a specific postcode?**
The current implementation scrapes the top-deals homepage for each category. Postcode-specific results require a JS-rendered comparison flow that is not yet supported.

**How many deals can I get?**
Typically 10–20 deals per category page. Set `maxItems` to control the output cap.

# Actor input Schema

## `mode` (type: `string`):

Which uSwitch broadband category to scrape deals from. Car and home insurance require user input (registration, postcode) and cannot be scraped without a browser.

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

Maximum number of deals to return (1–100).

## Actor input object example

```json
{
  "mode": "broadband",
  "maxItems": 20
}
```

# Actor output Schema

## `deals` (type: `string`):

Dataset containing all scraped uSwitch comparison deals.

# 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 = {
    "mode": "broadband",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/uswitch-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 = {
    "mode": "broadband",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/uswitch-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 '{
  "mode": "broadband",
  "maxItems": 20
}' |
apify call crawlerbros/uswitch-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "uSwitch Scraper - UK Broadband Deals Comparison",
        "description": "Scrape uSwitch.com for UK broadband deals - standard broadband, cheapest broadband, and mobile broadband. Extract product name, provider, pricing, speed, contract length, features, ratings, and apply URLs for every listed deal.",
        "version": "1.0",
        "x-build-id": "H5Bs7IZASuzUhPnDd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~uswitch-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-uswitch-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/crawlerbros~uswitch-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-uswitch-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/crawlerbros~uswitch-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-uswitch-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Category",
                        "enum": [
                            "broadband",
                            "cheapBroadband",
                            "mobileBroadband"
                        ],
                        "type": "string",
                        "description": "Which uSwitch broadband category to scrape deals from. Car and home insurance require user input (registration, postcode) and cannot be scraped without a browser.",
                        "default": "broadband"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of deals to return (1–100).",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
