# Gumtree Scraper - UK Classifieds Data (`benthepythondev/gumtree-scraper`) Actor

Scrape Gumtree UK listings from search URLs with title, price, location, image, listing URL and featured status. Works well for UK property and classifieds monitoring.

- **URL**: https://apify.com/benthepythondev/gumtree-scraper.md
- **Developed by:** [ben](https://apify.com/benthepythondev) (community)
- **Categories:** Real estate, Lead generation, E-commerce
- **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. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Scraper - UK Classifieds Data

Scrape listings from **Gumtree UK** in one run. Paste any Gumtree search-results URL and get clean listing rows with title, price, price period, location, image, listing URL, listing ID and featured status. It works especially well for Gumtree property categories such as flats, houses, rooms, commercial space and parking, and can also be used for other public Gumtree classifieds searches where the same listing-card structure is available. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### What is the Gumtree Scraper?

Gumtree is one of the UK's best-known local classifieds marketplaces. It is used for rentals, property, cars, jobs, furniture, services, local deals and many other categories. This actor turns Gumtree search pages into structured data so you can monitor listings, prices and supply without manually copying search results.

The actor is built for reliability. It reads the server-rendered search-result cards that Gumtree sends in the HTML, rather than using a browser or fighting a private API. That keeps runs fast, cheap and friendly to Apify's daily auto-test requirements. You can apply filters on Gumtree first, copy the resulting URL, and paste it into the actor.

#### What data does it extract?

**Listing identity:** Gumtree listing ID, title and direct listing URL.

**Price data:** displayed price, numeric price, price period such as month or week, and currency.

**Location:** the location text shown on the Gumtree card.

**Media:** primary image URL, image alt text and image count when Gumtree shows it.

**Promotion signals:** featured listing flag.

**Source data:** the exact search URL/page that produced the listing.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `searchUrls` | array | Gumtree.com search-result URLs. Use Gumtree's filters first, then paste the URL. |
| `maxResults` | integer | Maximum listings to return across all URLs. |
| `maxPages` | integer | Maximum result pages to fetch per URL. |

#### Example input

```json
{
  "searchUrls": [
    "https://www.gumtree.com/flats-houses/uk/london"
  ],
  "maxResults": 30,
  "maxPages": 2
}
````

### Output

Each listing is pushed as one dataset item.

```json
{
  "id": "1502671936",
  "title": "Storage - E-Commerce Space to Rent in Greenford",
  "description": "Private Date available: 13 Jul 2026 Industrial",
  "url": "https://www.gumtree.com/p/commercial-property-to-rent/...",
  "price": 1249,
  "price_raw": "£1,249pm",
  "price_period": "month",
  "currency": "GBP",
  "location": "Greenford, London",
  "image": "https://img.gumtree.com/...",
  "image_alt": "Storage - E-Commerce Space to Rent in Greenford",
  "image_count": 20,
  "is_featured": true,
  "source_url": "https://www.gumtree.com/flats-houses/uk/london?sort=date"
}
```

### Use cases

**UK property monitoring:** Track Gumtree rentals, rooms, commercial space and property listings by city or category.

**Classifieds price tracking:** Monitor prices for local inventory, second-hand goods, services, vehicles or property categories.

**Lead generation:** Find fresh listings and connect Gumtree listing URLs to downstream enrichment or outreach workflows.

**Market research:** Measure listing supply, asking prices, featured ads and local marketplace movement over time.

**Automation:** Schedule searches and push new rows into a spreadsheet, CRM, Slack channel, database or BI dashboard.

### FAQ

**Does it work with any Gumtree URL?** It is designed for public Gumtree search-result URLs. Property and classifieds category URLs with standard listing cards work best.

**Do I need a Gumtree account?** No. The actor reads public search pages and does not require a Gumtree login.

**Can I filter by category or city?** Yes. Apply filters on Gumtree, copy the resulting URL and paste it into `searchUrls`.

**Does it scrape detail pages?** This version focuses on search-result cards for speed and reliability. Detail-page crawling can be added later if there is enough demand.

**Why is some data missing?** Gumtree cards vary by category. Some listings may not show a price, image count or full description in the search results.

**Does it use a browser or proxy?** No. The tested path uses direct HTTP requests and lxml parsing, making it cheaper and more reliable than browser-based scraping.

**Is it legal to scrape Gumtree?** Use public data responsibly, respect Gumtree's terms and applicable laws, and avoid spam or unlawful outreach. For compliance-sensitive work, consult your legal team.

**Can I schedule it?** Yes. Apify schedules can run the same Gumtree search URLs daily, hourly or weekly.

### You might also like

- [Kijiji Scraper](https://apify.com/benthepythondev/kijiji-scraper) for Canadian classifieds and rentals.
- [Craigslist Real Estate Scraper](https://apify.com/benthepythondev/craigslist-real-estate-scraper) for US classifieds property data.
- [Kleinanzeigen Immobilien Scraper](https://apify.com/benthepythondev/kleinanzeigen-immobilien-scraper) for German real-estate classifieds.
- [Website Contact Extractor](https://apify.com/benthepythondev/website-contact-extractor) for extracting emails and phone numbers from websites.

**Keywords:** Gumtree scraper, Gumtree UK scraper, Gumtree API, Gumtree classifieds scraper, Gumtree property scraper, UK rentals scraper, UK classifieds data, Gumtree listings export, Gumtree price tracker, London rentals data, classifieds lead generation, property monitoring UK, Apify Gumtree scraper, Gumtree search scraper, local marketplace data

# Actor input Schema

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

Paste Gumtree.com search-result URLs. Apply filters on Gumtree first, then paste the URL.

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

Maximum listings to return across all URLs.

## `maxPages` (type: `integer`):

Maximum Gumtree result pages to fetch per URL.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.gumtree.com/flats-houses/uk/london"
  ],
  "maxResults": 10,
  "maxPages": 1
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchUrls": [
        "https://www.gumtree.com/flats-houses/uk/london"
    ],
    "maxResults": 10,
    "maxPages": 1
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "searchUrls": ["https://www.gumtree.com/flats-houses/uk/london"],
    "maxResults": 10,
    "maxPages": 1,
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchUrls": [
    "https://www.gumtree.com/flats-houses/uk/london"
  ],
  "maxResults": 10,
  "maxPages": 1
}' |
apify call benthepythondev/gumtree-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gumtree Scraper - UK Classifieds Data",
        "description": "Scrape Gumtree UK listings from search URLs with title, price, location, image, listing URL and featured status. Works well for UK property and classifieds monitoring.",
        "version": "1.0",
        "x-build-id": "hn0kuc6RvfHXh7FsN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~gumtree-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-gumtree-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/benthepythondev~gumtree-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-gumtree-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/benthepythondev~gumtree-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-gumtree-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchUrls": {
                        "title": "Gumtree search URLs",
                        "type": "array",
                        "description": "Paste Gumtree.com search-result URLs. Apply filters on Gumtree first, then paste the URL.",
                        "default": [
                            "https://www.gumtree.com/flats-houses/uk/london"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum listings to return across all URLs.",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Max pages per URL",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum Gumtree result pages to fetch per URL.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```