# Gumtree Listings Scraper (`unfenced-group/gumtree-scraper`) Actor

Scrape Gumtree classified listings by search URL. Extract titles, prices, locations, descriptions, images, and seller info. No login needed.

- **URL**: https://apify.com/unfenced-group/gumtree-scraper.md
- **Developed by:** [Unfenced Group](https://apify.com/unfenced-group) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

Scrape classified listings from Gumtree across three countries: the United Kingdom ([gumtree.com](https://www.gumtree.com)), Australia ([gumtree.com.au](https://www.gumtree.com.au)), and South Africa ([gumtree.co.za](https://www.gumtree.co.za)). Search by keyword or paste a search URL, and get structured listing data with optional full detail enrichment.

![Gumtree Listings Scraper](https://api.apify.com/v2/key-value-stores/lJlifu6C8YQfZMPKE/records/gumtree-scraper)

### What it does

Provide a keyword (with a region) or a search URL, and the scraper returns clean, structured data for every listing. Region is detected automatically from the URL, so you can mix UK, Australian, and South African searches in one run.

Each listing includes the title, numeric and text price, currency, location, and a thumbnail. Turn on `fetchDetails` to also get the full description, all images, geo-coordinates (latitude and longitude), postcode, seller type, posted date, and — for cars — a complete vehicle specification.

It works across every Gumtree category: phones, cars, property, furniture, electronics, jobs, services, and general for-sale items.

### Pricing

The scraper uses two pay-per-result events. You pay only for what you collect; we absorb all compute and proxy costs.

| Event | Price (FREE tier) | When it applies |
|---|---|---|
| Listing scraped | $0.99 / 1,000 | Every listing returned from search |
| Listing detail enriched | $4.99 / 1,000 | Each listing when `fetchDetails` is on |

Listing-only runs cost $0.99 per 1,000 in every region. Detail enrichment is billed separately because Australian detail pages are fetched through residential proxies. Lower prices apply at higher Apify usage tiers.

### Input

| Field | Type | Description |
|---|---|---|
| `startUrls` | Array | Gumtree search URLs. Region detected per URL. Paste straight from your browser. |
| `keyword` | String | Search keyword. Used when `startUrls` is empty. |
| `region` | String | Region for keyword search: `uk`, `au`, or `za`. Default `uk`. |
| `location` | String | UK location name (e.g. `london`). UK keyword search only. |
| `category` | String | UK category slug (e.g. `cars`, `phones`). UK keyword search only. |
| `sortOrder` | String | UK sort: `date`, `price_asc`, or `price_desc`. |
| `fetchDetails` | Boolean | Fetch each listing's detail page for full data. Default `false`. |
| `maxResults` | Integer | Maximum listings to collect. Default `5`. |

#### Example — keyword search, Australia

```json
{
  "keyword": "toyota hilux",
  "region": "au",
  "maxResults": 200,
  "fetchDetails": true
}
````

#### Example — keyword search, United Kingdom

```json
{
  "keyword": "iphone",
  "region": "uk",
  "location": "manchester",
  "category": "phones",
  "maxResults": 500
}
```

#### Example — paste a search URL

```json
{
  "startUrls": [
    { "url": "https://www.gumtree.co.za/s-cars-bakkies/v1c9077p1" }
  ],
  "fetchDetails": true
}
```

### Output

Each listing is one dataset record. Listing-level fields are always present; the rest are added when `fetchDetails` is on.

```json
{
  "id": "1512318051",
  "region": "uk",
  "title": "2019 Ford Focus 1.5 EcoBlue ST-Line",
  "price": 9490,
  "currency": "GBP",
  "priceText": "£9,490",
  "location": "Oldham, Manchester",
  "latitude": 53.55,
  "longitude": -2.1,
  "postcode": "OL41JZ",
  "area": "oldham",
  "category": "Motors",
  "subcategory": "Cars",
  "condition": "used",
  "sellerType": "Trade",
  "sellerName": "Motor Warehouse Ltd",
  "postedAt": "2026-04-11T17:24:42.352Z",
  "numberOfImages": 30,
  "images": ["https://..."],
  "description": "...",
  "vehicle": {
    "make": "Ford",
    "model": "FOCUS",
    "year": "2019",
    "mileage": 53600,
    "fuelType": "Diesel",
    "transmission": "Manual",
    "combinedMpg": 67.3,
    "co2Gkm": 110,
    "hpiNotStolen": true,
    "hpiNotWriteoff": true
  },
  "url": "https://www.gumtree.com/p/ford/...",
  "scrapedAt": "2026-06-26T02:33:00.000Z"
}
```

Cars carry a full `vehicle` block (make, model, year, mileage, fuel, transmission, engine, emissions, MPG, HPI history flags, and more) when `fetchDetails` is on. Non-vehicle listings omit it.

### Regions and coverage

| Region | Site | Currency | Proxy |
|---|---|---|---|
| United Kingdom | gumtree.com | GBP | None |
| Australia | gumtree.com.au | AUD | Residential (included) |
| South Africa | gumtree.co.za | ZAR | Residential (included) |

### Use cases

- Used-car and dealer intelligence: aggregate vehicle listings with structured specs for benchmarking and inventory analysis.
- Pricing and market research: track second-hand price curves and compare across regions.
- Lead generation: build region-specific listing directories with location and seller-type data.
- Reseller sourcing and arbitrage: find underpriced items across categories and countries.
- Property and rental analysis: map listing density and asking prices by area.

### Notes

The scraper does not collect private individuals' personal names, phone numbers, or email addresses. Business and dealer names are included where Gumtree publishes them. This keeps the data suitable for commercial market-intelligence use.

Some fields depend on what each listing publishes. Posted dates, seller type, and vehicle specs are populated where the source exposes them and left empty where it does not.

# Actor input Schema

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

Gumtree search-result URLs to scrape. Region (UK / Australia / South Africa) is detected automatically from each URL. Paste directly from your browser.

## `keyword` (type: `string`):

Search keyword. Used only when startUrls is empty.

## `region` (type: `string`):

Which Gumtree site to search when using a keyword: uk (gumtree.com), au (gumtree.com.au), or za (gumtree.co.za). Australia and South Africa are routed through residential proxies automatically.

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

Location name for UK keyword search (e.g. london, manchester). Ignored for AU/ZA.

## `category` (type: `string`):

UK category slug for keyword search (e.g. all, for-sale, cars, phones).

## `sortOrder` (type: `string`):

UK sort: date (newest first), price\_asc, or price\_desc.

## `fetchDetails` (type: `boolean`):

Open each listing's detail page for full description, all images, geo-coordinates, seller type, posted date, and (cars) full vehicle specs. Slower and billed at the detail rate. For Australia this uses residential proxy bandwidth.

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

Maximum number of listings to scrape across all search URLs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.gumtree.com/search?search_category=all&q=iphone&search_location=london"
    }
  ],
  "region": "uk",
  "location": "",
  "category": "all",
  "sortOrder": "date",
  "fetchDetails": false,
  "maxResults": 5
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.gumtree.com/search?search_category=all&q=iphone&search_location=london"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("unfenced-group/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 = { "startUrls": [{ "url": "https://www.gumtree.com/search?search_category=all&q=iphone&search_location=london" }] }

# Run the Actor and wait for it to finish
run = client.actor("unfenced-group/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 '{
  "startUrls": [
    {
      "url": "https://www.gumtree.com/search?search_category=all&q=iphone&search_location=london"
    }
  ]
}' |
apify call unfenced-group/gumtree-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gumtree Listings Scraper",
        "description": "Scrape Gumtree classified listings by search URL. Extract titles, prices, locations, descriptions, images, and seller info. No login needed.",
        "version": "0.0",
        "x-build-id": "eT1vylvD2KX743Mr2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/unfenced-group~gumtree-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-unfenced-group-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/unfenced-group~gumtree-scraper/runs": {
            "post": {
                "operationId": "runs-sync-unfenced-group-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/unfenced-group~gumtree-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-unfenced-group-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": {
                    "startUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Gumtree search-result URLs to scrape. Region (UK / Australia / South Africa) is detected automatically from each URL. Paste directly from your browser.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keyword": {
                        "title": "Keyword (if no search URL)",
                        "type": "string",
                        "description": "Search keyword. Used only when startUrls is empty."
                    },
                    "region": {
                        "title": "Region (for keyword search)",
                        "enum": [
                            "uk",
                            "au",
                            "za"
                        ],
                        "type": "string",
                        "description": "Which Gumtree site to search when using a keyword: uk (gumtree.com), au (gumtree.com.au), or za (gumtree.co.za). Australia and South Africa are routed through residential proxies automatically.",
                        "default": "uk"
                    },
                    "location": {
                        "title": "Location (UK only)",
                        "type": "string",
                        "description": "Location name for UK keyword search (e.g. london, manchester). Ignored for AU/ZA.",
                        "default": ""
                    },
                    "category": {
                        "title": "Category (UK only)",
                        "type": "string",
                        "description": "UK category slug for keyword search (e.g. all, for-sale, cars, phones).",
                        "default": "all"
                    },
                    "sortOrder": {
                        "title": "Sort order (UK only)",
                        "type": "string",
                        "description": "UK sort: date (newest first), price_asc, or price_desc.",
                        "default": "date"
                    },
                    "fetchDetails": {
                        "title": "Fetch detail pages",
                        "type": "boolean",
                        "description": "Open each listing's detail page for full description, all images, geo-coordinates, seller type, posted date, and (cars) full vehicle specs. Slower and billed at the detail rate. For Australia this uses residential proxy bandwidth.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape across all search URLs.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
