# Gumtree Scraper (Cheap) (`data_api/gumtree-scraper-cheap`) Actor

Gumtree scraper that pulls listing titles, prices, locations, and URLs from search results, so you can track the UK classifieds market without doing it by hand.

- **URL**: https://apify.com/data\_api/gumtree-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **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

## Gumtree Listings Scraper

![Gumtree Listings Scraper](cover.jpg)

Watching the UK classifieds usually means refreshing Gumtree search pages and copying ad titles, prices, and locations by hand. This scraper does the legwork. Type in a keyword or two, and every matching ad comes back as a tidy row with the price, seller area, posting age, and link already split into fields you can drop into a spreadsheet. It runs fast, costs little, needs no code, and you pay only for the ads you pull.

### What you get

Each ad comes back as one row, grouped into three kinds of data:

- **The ad** — `adId`, `adTitle`, `askingPrice`, `askingPricePence`, `adUrl`, `imageCount`, `videoIncluded`
- **The seller and listing** — `sellerArea`, `daysListed`, `tradeSeller`, `featuredAd`, `deliveryOffered`, `identityVerified`, `categoryCode`
- **Search context** — `queryTerm`, `queryArea`, `queryCategory`, `resultRank`, `rankingSource`, `matchesFound`, `resultPage`, `collectedAt`

### Quick start

1. Hit **Try for free** and type your keywords into **Search terms** (one search runs per keyword).
2. Optionally add **Area slugs** (like leeds) or **Category slugs** (like bicycles) to narrow things down.
3. Set **Results per query** to cap how many ads you pull per combination.
4. Press **Start**, then export the rows as JSON, CSV, Excel, or XML.

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

### Use cases

- **Price research** — see what used gear, furniture, or vehicles actually sell for across the country
- **Deal hunting** — track new ads for a specific item and act before they're gone
- **Reseller sourcing** — find underpriced stock by keyword and area, then flip it
- **Market analysis** — measure supply and pricing by category, region, or trade-versus-private seller
- **Lead building** — collect trade sellers in a category to reach out to

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchTerms` | array of strings | Yes | Keywords to search; each one runs as its own search. Prefilled with `road bike`. |
| `areaSlugs` | array of strings | No | Area slugs that filter by place (e.g. leeds). Leave empty for the whole UK. Each area pairs with every keyword. |
| `categorySlugs` | array of strings | No | Category slugs that focus the search (e.g. bicycles). Leave empty for all categories. Each category pairs with every keyword and area. |
| `resultsPerQuery` | integer | No | Ads to gather per keyword/area/category combination. Total = combinations × this. Default `40`, max 500. |
| `timeoutSeconds` | integer | No | Seconds to wait on each request before giving up. Default `45`. |

#### Example input

```json
{
    "searchTerms": ["road bike", "ps5", "office desk"],
    "areaSlugs": ["leeds", "bristol", "glasgow"],
    "categorySlugs": ["bicycles", "cars-vans-motorbikes", "video-games-consoles"],
    "resultsPerQuery": 25,
    "timeoutSeconds": 45
}
````

### Output

Every ad on the search results becomes one row, paginated automatically up to your per-query limit. Fields Gumtree does not publish for a given ad come back empty rather than guessed.

#### Example output

```json
{
    "adId": 1487293045,
    "adTitle": "Carrera road bike, 56cm, recently serviced",
    "askingPrice": 220,
    "askingPricePence": 22000,
    "sellerArea": "Headingley, Leeds",
    "daysListed": 3,
    "tradeSeller": false,
    "featuredAd": false,
    "deliveryOffered": true,
    "identityVerified": true,
    "categoryCode": 2782,
    "imageCount": 6,
    "videoIncluded": false,
    "resultRank": 4,
    "rankingSource": "primary",
    "adUrl": "https://www.gumtree.com/p/bicycles/carrera-road-bike-56cm-recently-serviced/1487293045",
    "queryTerm": "road bike",
    "queryArea": "leeds",
    "queryCategory": "bicycles",
    "matchesFound": 318,
    "resultPage": 1,
    "collectedAt": "2026-06-29T12:00:00.000000+00:00"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `adId` | integer | Numeric identifier Gumtree assigns to the ad |
| `adTitle` | string | Headline of the ad as shown on Gumtree |
| `askingPrice` | integer | Price in pounds; 0 marks a free item |
| `askingPricePence` | integer | Same price in pence for exact figures |
| `sellerArea` | string | Where the seller is based, e.g. Salford, Manchester |
| `daysListed` | integer | Days since the ad went up |
| `tradeSeller` | boolean | True for a registered business or trade account |
| `featuredAd` | boolean | True when the ad holds a paid featured slot |
| `deliveryOffered` | boolean | True when the seller will ship or deliver |
| `identityVerified` | boolean | True when the seller cleared GBG identity checks |
| `categoryCode` | integer | Numeric code for the ad's category |
| `imageCount` | integer | Number of photos on the ad |
| `videoIncluded` | boolean | True when the ad carries a video link |
| `resultRank` | integer | Zero-based slot the ad held in the results |
| `rankingSource` | string | Why Gumtree surfaced the result (primary, entity, payShipping) |
| `adUrl` | string | Full web address of the ad page |
| `queryTerm` | string | Keyword that surfaced the ad |
| `queryArea` | string | Area slug used; empty means the whole UK |
| `queryCategory` | string | Category slug used; empty means all categories |
| `matchesFound` | integer | Ads Gumtree reports for the search |
| `resultPage` | integer | Results page the ad came from |
| `collectedAt` | string | ISO 8601 UTC timestamp of capture |

### Tips for best results

- **Be specific with keywords.** A tight term like `carrera road bike` returns cleaner, more relevant ads than a broad one like `bike`.
- **Start small.** Set `resultsPerQuery` to 25 for a test run, check the rows fit your pipeline, then raise it.
- **Watch the multiplication.** Three keywords across three areas and three categories is 27 combinations, each pulling up to your limit, so the total adds up quickly.
- **Use `queryArea` and `queryCategory` to split data.** Every row records the search that produced it, so you can group and compare without keeping track yourself.
- **Raise `timeoutSeconds`** if requests start timing out on bigger pulls.

### How can I use Gumtree listings data?

**How can I use the Gumtree Listings Scraper to track second-hand prices?**
Run your keywords on a schedule and keep the rows. Each one carries `askingPrice`, `adTitle`, `sellerArea`, and `daysListed`, so you can chart what items go for over time and spot when ads are sitting unsold.

**How can I find underpriced items on Gumtree to resell?**
Search a category by keyword, sort the export by `askingPrice`, and check `daysListed` and `deliveryOffered` to judge the deal. Pair `sellerArea` with `tradeSeller` to tell private bargains from business stock.

**How can I build a UK classifieds dataset for market research?**
Feed in several keywords, areas, and categories, set `resultsPerQuery` to the volume you need, and export to CSV or Excel. You get a structured ad database (title, price, area, category, seller type) ready to score or visualise.

**How can I monitor a specific Gumtree category or area?**
Add the matching `categorySlugs` and `areaSlugs`, then rerun whenever you want a fresh snapshot. Every row keeps `queryCategory` and `queryArea` so the data stays organised across runs.

### 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`):

Keywords to look up on Gumtree. Every keyword runs as its own search, capped at the per-query result limit you set below.

## `areaSlugs` (type: `array`):

Optional area slugs that narrow results by place (for example leeds or bristol). Skip this to cover the whole UK. Each area is paired with every keyword.

## `categorySlugs` (type: `array`):

Optional category slugs that focus the search (for example bicycles or cars). Skip this to span all categories. Each category is paired with every keyword and area.

## `resultsPerQuery` (type: `integer`):

How many ads to gather for each keyword, area, and category combination. The grand total equals the number of combinations multiplied by this value. Caps at 500.

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

How long to wait on each request before giving up.

## Actor input object example

```json
{
  "searchTerms": [
    "road bike",
    "ps5",
    "office desk"
  ],
  "areaSlugs": [
    "leeds",
    "bristol",
    "glasgow"
  ],
  "categorySlugs": [
    "bicycles",
    "cars-vans-motorbikes",
    "video-games-consoles"
  ],
  "resultsPerQuery": 25,
  "timeoutSeconds": 45
}
```

# 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": [
        "road bike"
    ],
    "areaSlugs": [],
    "categorySlugs": [],
    "resultsPerQuery": 25,
    "timeoutSeconds": 45
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/gumtree-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": ["road bike"],
    "areaSlugs": [],
    "categorySlugs": [],
    "resultsPerQuery": 25,
    "timeoutSeconds": 45,
}

# Run the Actor and wait for it to finish
run = client.actor("data_api/gumtree-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": [
    "road bike"
  ],
  "areaSlugs": [],
  "categorySlugs": [],
  "resultsPerQuery": 25,
  "timeoutSeconds": 45
}' |
apify call data_api/gumtree-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gumtree Scraper (Cheap)",
        "description": "Gumtree scraper that pulls listing titles, prices, locations, and URLs from search results, so you can track the UK classifieds market without doing it by hand.",
        "version": "0.0",
        "x-build-id": "juO9NQ0q7I7ObR1RH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~gumtree-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-gumtree-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~gumtree-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-gumtree-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~gumtree-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-gumtree-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",
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to look up on Gumtree. Every keyword runs as its own search, capped at the per-query result limit you set below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "areaSlugs": {
                        "title": "Area slugs",
                        "type": "array",
                        "description": "Optional area slugs that narrow results by place (for example leeds or bristol). Skip this to cover the whole UK. Each area is paired with every keyword.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categorySlugs": {
                        "title": "Category slugs",
                        "type": "array",
                        "description": "Optional category slugs that focus the search (for example bicycles or cars). Skip this to span all categories. Each category is paired with every keyword and area.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsPerQuery": {
                        "title": "Results per query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many ads to gather for each keyword, area, and category combination. The grand total equals the number of combinations multiplied by this value. Caps at 500.",
                        "default": 40
                    },
                    "timeoutSeconds": {
                        "title": "Timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on each request before giving up.",
                        "default": 45
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
