# Gumtree Scraper (`datascrapers/gumtree-scraper`) Actor

Gumtree UK listing dataset from search URLs, category filters, or listing links, including titles, prices, locations, seller information, and optional listing details.

- **URL**: https://apify.com/datascrapers/gumtree-scraper.md
- **Developed by:** [Farhan Ali](https://apify.com/datascrapers) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.97 / 1,000 product scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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** creates a structured dataset of classified listings collected from [Gumtree](https://www.gumtree.com), the UK classifieds marketplace. Each dataset item represents one listing and can include title, price, location, category, images, seller details, and contact fields when Gumtree publishes them. Query the source by pasting Gumtree search, category, or listing URLs, or by keyword search with category, location, seller-type, and condition filters. Control the result limit with `maxItems`, and retrieve records through the Apify Dataset API or export them as JSON, CSV, Excel, or other supported formats.

### Dataset at a glance

| Property | Value |
|---|---|
| Source | gumtree.com (UK classifieds marketplace) |
| Record unit | One Gumtree listing |
| Input methods | Gumtree URLs (`startUrls`) or keyword search (`searchQueries`) with category, location, seller-type, and condition filters |
| Main identifiers | `listingId`, `url` |
| Delivery | Apify Dataset and API |
| Export formats | JSON, CSV, Excel, XML, HTML (Apify dataset exports) |
| Update model | Fresh records per Actor run |
| Pricing | $1.00 per 1,000 listings (search cards); $1.50 per 1,000 listings when `extractListingDetails` is enabled |

### Coverage and available records

The Actor collects listings from public Gumtree pages using one of two entry points:

- **URL-based**: Pass Gumtree search, category, or listing URLs in `startUrls`. When `startUrls` is set, `searchQueries` is ignored and category, location, seller-type, and condition filters are optional.
- **Search-based**: Set `searchQueries` (for example `laptop`) with `category`, `subcategory`, `location`, `sellerType`, and `condition`. `category` defaults to `for-sale` and `location` defaults to `uk`.

Supported categories: `cars-and-vehicles`, `for-sale`, `services`, `property`, `pets`, `jobs`, `community`. `subcategory` is a Gumtree URL slug such as `computers-software`. `condition` applies to the for-sale category.

- **Listing-level records** always include `listingId`, `url`, `title`, `price`, `location`, `primaryImageUrl`, and `sourcePageUrl` when the search card publishes them.
- **Detail fields** (`description`, `imageUrls`, seller profile, `phoneNumber`) are returned only when `extractListingDetails` is enabled and Gumtree exposes them.
- **Job fields** (`employmentType`, `validThrough`) appear on job listings when published.
- **Result cap**: `maxItems` limits listings collected (`0` = unlimited, the default).

Known exclusions: login-only content (including many phone numbers); historical snapshots; messages, watchlists, and account-only seller dashboards.

### Data dictionary

Field names match dataset JSON properties exactly. Fields marked *conditional* appear only when `extractListingDetails` is enabled and Gumtree publishes the value. Empty values are omitted, not fabricated.

| Field | Type | Nullable | Description | Example |
|---|---|---:|---|---|
| `listingId` | string | No | Gumtree listing ID; recommended dedup key | `1801599902` |
| `url` | string | No | Listing page URL | `https://www.gumtree.com/p/laptops/-asus-zenbook-s14-ux5406sa-ultra-7-32gb-1tb/1801599902` |
| `title` | string | Yes | Listing title | `Asus Zenbook s14 UX5406SA - ultra 7 -32gb- 1TB` |
| `description` | string | Yes | Listing text; full body is *conditional* | — |
| `price` | string | Yes | Asking price as a string | `550.00` |
| `priceCurrency` | string | Yes | Currency code | `GBP` |
| `priceStatus` | string | Yes | Price status when published | — |
| `location` | string | Yes | Location as shown on the listing | `Saltcoats, North Ayrshire` |
| `area` | string | Yes | Area slug or label when published | — |
| `category` | string | Yes | Category label as shown on the listing | `For Sale` |
| `primaryImageUrl` | string | Yes | Primary image URL | `https://img.gumtree.com/ePR8PyKf84wPHx7_RYmEag/79d91e9b2c1d482280_bf437d4f6156/86` |
| `imageUrls` | string\[] | Yes | Image gallery URLs (*conditional*) | — |
| `phoneNumber` | string | Yes | Seller phone when exposed (*conditional*) | — |
| `phoneLoginRequired` | boolean | Yes | `true` when Gumtree requires login to view the phone | `true` |
| `sellerName` | string | Yes | Seller display name | `robert` |
| `contactName` | string | Yes | Contact name when published (*conditional*) | — |
| `sellerType` | string | Yes | Seller type as shown on the listing | `Standard` |
| `sellerUrl` | string | Yes | Seller profile URL (*conditional*) | — |
| `sellerRatingCount` | integer | Yes | Seller rating count (*conditional*) | — |
| `sellerActiveSince` | string | Yes | Seller activity tenure (*conditional*) | — |
| `datePosted` | string | Yes | Posted date (ISO-8601 when coercible) | — |
| `postedAt` | string | Yes | Created timestamp (ISO-8601) | `2026-08-16T05:18:31.884000+00:00` |
| `updatedAt` | string | Yes | Last-updated timestamp (ISO-8601) (*conditional*) | — |
| `validThrough` | string | Yes | Job listing expiry when published | — |
| `employmentType` | string | Yes | Job employment type when published | — |
| `featured` | boolean | Yes | Featured listing flag | `true` |
| `urgent` | boolean | Yes | Urgent listing flag | — |
| `breadcrumbs` | object\[] | Yes | Category path `{name, url}` (*conditional*) | — |
| `sourcePageUrl` | string | Yes | Search or category page the listing was found on | — |

#### Breadcrumb object

| Field | Type | Nullable | Description |
|---|---|---:|---|
| `name` | string | No | Breadcrumb label |
| `url` | string | No | Breadcrumb URL |

### Example dataset record

Real record from the test input below (`for-sale` / `computers-software` / `uk`, private sellers, `as-good-as-new`, `extractListingDetails: true`, `maxItems: 5`). Unpublished fields are omitted.

```json
{
  "listingId": "1801599902",
  "title": "Asus Zenbook s14 UX5406SA - ultra 7 -32gb- 1TB",
  "price": "550.00",
  "priceCurrency": "GBP",
  "location": "Saltcoats, North Ayrshire",
  "url": "https://www.gumtree.com/p/laptops/-asus-zenbook-s14-ux5406sa-ultra-7-32gb-1tb/1801599902",
  "primaryImageUrl": "https://img.gumtree.com/ePR8PyKf84wPHx7_RYmEag/79d91e9b2c1d482280_bf437d4f6156/86",
  "sellerName": "robert",
  "sellerType": "Standard",
  "phoneLoginRequired": true,
  "category": "For Sale",
  "featured": true,
  "postedAt": "2026-08-16T05:18:31.884000+00:00"
}
```

The record above was produced with this input:

```json
{
  "category": "for-sale",
  "subcategory": "computers-software",
  "location": "uk",
  "sellerType": "private",
  "condition": "as-good-as-new",
  "extractListingDetails": true,
  "maxConcurrency": 10,
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Query and input reference

| Input | Type | Required | Default | Accepted values | Description |
|---|---|---|---|---|---|
| `startUrls` | array (requestListSources) | No | — | Gumtree search, category, or listing URLs | URL entry point. When set, `searchQueries` is ignored and filters are optional |
| `searchQueries` | array (string) | No | — | Free-text keywords (e.g. `laptop`) | Keyword search. Ignored when `startUrls` is set |
| `category` | string | No | `for-sale` | `cars-and-vehicles`, `for-sale`, `services`, `property`, `pets`, `jobs`, `community` | Top-level category when no `startUrls` |
| `subcategory` | string | No | — | Gumtree slug (e.g. `computers-software`) | Subcategory slug from Gumtree URLs |
| `location` | string | No | `uk` | Location slug | Search location filter |
| `sellerType` | string | No | — | `private`, `business` | Private or business sellers |
| `condition` | string | No | — | `new`, `as-good-as-new`, `good`, `fair`, `poor` | For-sale condition filter |
| `extractListingDetails` | boolean | No | `false` | `true` / `false` | Collect description, images, seller info, and phone when exposed (`listing-details` event) |
| `maxConcurrency` | integer | No | `10` | `1`–`50` | Parallel listing-page fetches when details are enabled |
| `maxItems` | integer | No | `0` | `0` or any positive integer | Maximum listings; `0` = unlimited |
| `proxyConfiguration` | object | No | Apify proxy, `RESIDENTIAL` | Apify or custom proxies | Residential recommended; Gumtree blocks datacenter traffic |

Minimal request:

```json
{ "searchQueries": ["laptop"], "category": "for-sale", "location": "uk" }
```

Advanced request (filters with detail enrichment):

```json
{
  "category": "for-sale",
  "subcategory": "computers-software",
  "location": "uk",
  "sellerType": "private",
  "condition": "as-good-as-new",
  "extractListingDetails": true,
  "maxConcurrency": 10,
  "maxItems": 5000,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Retrieve the data through the API

The Actor is published at <https://apify.com/datascrapers/gumtree-scraper>.

1. Start the Actor with a JSON input (console or API).
2. Wait for the run to finish, or use a synchronous endpoint if you want the response inline.
3. Retrieve items from the run's default dataset.
4. Paginate or export the dataset.

Python example:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR-APIFY-TOKEN")

run_input = {
    "searchQueries": ["laptop"],
    "category": "for-sale",
    "subcategory": "computers-software",
    "location": "uk",
    "extractListingDetails": True,
    "maxItems": 10,
}

run = client.actor("datascrapers/gumtree-scraper").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["listingId"], item["title"], item["price"])
```

Apify generates Python, JavaScript, and cURL examples on the Actor's API tab. Do not put a real API token in shared code or URLs.

### Data quality and record handling

- **Conditional fields**: description, galleries, seller profile, and phone appear only when `extractListingDetails` is enabled and Gumtree publishes them.
- **Source changes**: unpublished fields are omitted rather than fabricated.
- **Deduplication**: listings are unique by URL within a run. Across runs, use `listingId` (or `url`) as the stable key.
- **Phone numbers**: many listings set `phoneLoginRequired` to `true` and omit `phoneNumber`. Login-gated numbers are not collected.
- **Normalization**: `listingId` and `price` are strings; `sellerRatingCount` is an integer; `featured`, `urgent`, and `phoneLoginRequired` are booleans; timestamps are ISO-8601 when coercible.
- **Residential proxies**: Gumtree blocks datacenter traffic. Use the default residential `proxyConfiguration`.

### Export and pipeline examples

| Destination | Recommended method | Typical use |
|---|---|---|
| PostgreSQL / Supabase | Dataset API poll or webhook consumer | Store listings alongside price-monitoring tables |
| Google Sheets | Apify Google Sheets integration | Share listing shortlists with research teams |
| CRM (HubSpot, Salesforce) | Webhook on run completion | Push new listings into outreach pipelines |
| S3 / cloud storage | Scheduled export via Apify scheduler + integration | Archival of marketplace snapshots |

### Pricing and cost examples

Pay-per-event: each listing is billed as `dataset-item` when `extractListingDetails` is off, or `listing-details` when it is on. A one-time Actor start charge of $0.00005 applies per run.

| Event | Trigger | Rate (per 1,000 listings) |
|---|---|---|
| Actor start | Once per run | $0.00005 per run |
| Listing result (`dataset-item`) | Listing pushed with `extractListingDetails` off | $1.00 |
| Listing details (`listing-details`) | Listing pushed with `extractListingDetails` on | $1.50 |

| Records | Configuration | Estimated base cost |
|---:|---|---:|
| 1,000 | Search cards only | $1.00 |
| 10,000 | Search cards only | $10.00 |
| 1,000 | Listing details enabled | $1.50 |
| 10,000 | Listing details enabled | $15.00 |

Apify paid plans reduce the per-1,000 rate (for example $0.97 per 1,000 listings and $1.20 per 1,000 detail pages at Gold). Bronze and Silver apply smaller discounts. Estimates depend on the verified pricing model and selected options.

### Limitations and responsible data use

- The Actor collects publicly accessible Gumtree page data only.
- Field availability depends on what Gumtree renders at run time; values can be missing.
- Phone numbers are often unavailable without a Gumtree login; `phoneLoginRequired` reports that state.
- The Actor does not provide historical snapshots unless you store them yourself.
- Large runs require residential proxies; datacenter traffic is blocked.
- You are responsible for compliance with Gumtree's terms of service, applicable privacy law, and any contractual obligations before using the data.

### Dataset questions

#### What does one dataset item represent?

One Gumtree listing. `extractListingDetails` adds description, images, seller information, and phone fields to that same record when Gumtree exposes them.

#### Which field should I use as a unique identifier?

`listingId` is the recommended deduplication key. Use `url` when `listingId` is missing.

#### Are fields nullable or conditional?

Yes. Detail fields exist only when `extractListingDetails` is enabled. Unpublished fields are omitted. `employmentType` and `validThrough` appear on job listings when published.

#### Can I retrieve the records as CSV or JSON?

Yes. Export JSON, CSV, Excel, XML, or HTML from the Apify Console, or query the Dataset API.

#### Does the Actor return historical data?

No. Each run captures listings at run time. Schedule repeated runs and store outputs to track changes.

#### What counts as a billable result?

One event per listing: $1.00 per 1,000 search-card records, or $1.50 per 1,000 when `extractListingDetails` is enabled. Those events are alternatives, not added together. Actor start is $0.00005 once per run.

### Related datasets from Data Scrapers

- **[Etsy Scraper](https://apify.com/datascrapers/etsy-scraper)** — Marketplace goods comparable with Gumtree for-sale listings.
- **[Amazon Search Scraper](https://apify.com/datascrapers/amazon-scraper)** — Retail product records for classifieds price comparison.
- **[Cars.com Scraper](https://apify.com/datascrapers/cars-scraper)** — US vehicles alongside Gumtree cars-and-vehicles.
- **[AutoScout24 Scraper](https://apify.com/datascrapers/autoscout24-scraper)** — European vehicles for cross-market automotive research.
- **[Apartments.com Scraper](https://apify.com/datascrapers/apartments-scraper)** — US rentals alongside Gumtree property ads.
- **[Realtor.com Scraper](https://apify.com/datascrapers/realtor-scraper)** — US property listings comparable with Gumtree property.

### Data Scrapers support

Need an additional field, record type, or export workflow? Contact Data Scrapers at stardustspotlight@gmail.com. Include a sample source URL, required fields, expected record volume, and preferred delivery format.

# Actor input Schema

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

Gumtree search, category, or listing URLs. When provided, other filters are optional.

## `searchQueries` (type: `array`):

Free-text keywords combined with category/location filters (ignored when startUrls are set).

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

Top-level Gumtree category used when building search URLs without a start URL.

## `subcategory` (type: `string`):

Category slug from Gumtree URLs, e.g. computers-software, cars, leisure-and-tourism-jobs.

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

Location slug for search results (default: uk).

## `sellerType` (type: `string`):

Filter listings by private or business/trade sellers.

## `condition` (type: `string`):

For-sale condition filter (for-sale category).

## `extractListingDetails` (type: `boolean`):

When enabled, visits each listing page for full data (description, images, seller info, phone). Uses the listing-details charge event. When disabled, only search-result card data is extracted (faster, lower cost).

## `maxConcurrency` (type: `integer`):

Number of listing detail pages fetched in parallel when Extract listing details is enabled. Each request uses a fresh residential proxy session.

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

Maximum number of listings to scrape (0 = unlimited).

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

Apify residential proxy is recommended — Gumtree blocks datacenter traffic.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.gumtree.com/search?search_category=computers-software&search_location=uk&seller_type=private"
    }
  ],
  "searchQueries": [
    "laptop"
  ],
  "category": "for-sale",
  "subcategory": "computers-software",
  "location": "uk",
  "extractListingDetails": false,
  "maxConcurrency": 10,
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing scraped Gumtree listings

## `runStats` (type: `string`):

Run statistics including recordsScraped and timestamps

# 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=computers-software&search_location=uk&seller_type=private"
        }
    ],
    "searchQueries": [
        "laptop"
    ],
    "subcategory": "computers-software",
    "location": "uk",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascrapers/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=computers-software&search_location=uk&seller_type=private" }],
    "searchQueries": ["laptop"],
    "subcategory": "computers-software",
    "location": "uk",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.gumtree.com/search?search_category=computers-software&search_location=uk&seller_type=private"
    }
  ],
  "searchQueries": [
    "laptop"
  ],
  "subcategory": "computers-software",
  "location": "uk",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call datascrapers/gumtree-scraper --silent --output-dataset

```

## MCP server setup

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

```

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

## OpenAPI specification

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