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

\[💰 $1.5 / 1K] Extract classified listings from Gumtree across the UK, Australia, and South Africa. Get titles, prices, locations, descriptions, images, attributes (beds/baths, mileage/year, etc.), seller info, and contact details for cars, property, jobs, services, and general for-sale items.

- **URL**: https://apify.com/solidcode/gumtree-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Lead generation, Real estate, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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

Pull classified ads from Gumtree at scale across three country sites — UK (gumtree.com), South Africa (gumtree.co.za), and Australia (gumtree.com.au). Get titles, prices in local currency, locations with geo-coordinates, descriptions, image galleries, structured attributes (mileage, year, beds, baths), seller name and type, and phone numbers where the seller has published one. Built for classifieds resellers, used-car dealers, and pricing-intelligence teams who need fresh, structured Gumtree data without stitching together three different country sites and parsing inconsistent HTML.

### Why This Scraper?

- **Three country sites, one schema** — UK, South Africa, and Australia listings normalised into a single flat row shape with the same 27 fields, so a downstream CSV doesn't care which domain a listing came from.
- **Cars & Vehicles across the UK, ZA, and AU** — used-car pricing in the United Kingdom, pan-regional South Africa (`gumtree.co.za/s-cars-bakkies`), and Australia-wide (`gumtree.com.au` cars), with mileage, year, transmission, fuel type, body type, make, model, and drivetrain pulled into structured `attributes`.
- **Six UK + ZA top-level categories** — Cars & Vehicles, Property (Houses & Flats), Jobs, Pets, Community, and the For Sale general-goods catalogue. Australia is focused on Cars & Vehicles.
- **Daily monitoring via `listingStartDate` early-stop** — set a cutoff date and pagination stops the moment listings get older than that, so an overnight delta run pays for new ads only — typically a 90% credit saving versus a full re-crawl.
- **Seller-type identification for trust signals** — every listing tagged `business` vs `private`, with the seller display name captured, so dealer-only or private-only filtering happens at the dataset level instead of in your post-processing.
- **Geo-coordinates and postcodes on detail rows** — latitude, longitude, and postcode populated where Gumtree publishes rich location data on the listing detail page, ready for map plotting or radius search.
- **Free-text location or postcode prefix** — `London`, `Manchester`, `Cape Town`, `Perth`, `SW1A` all resolve to the right region slug automatically; no need to hand-craft `/cars/uk/london` style paths.
- **Phone-number capture for South Africa & Australia cars** — toggle `includePhone` to pick up the seller's published phone number on `gumtree.co.za` listings and `gumtree.com.au` cars where the dealer has exposed it. United Kingdom phone numbers stay behind Gumtree's click-to-reveal masking and are reported as `null` rather than returned half-masked.
- **Up to 50,000 listings per run** with `maxResults: 0` for unlimited (a 50k safety cap applies). Each individual search caps at roughly 1,800 rows from page-pagination depth — for larger pulls, split your run across multiple `startUrls`.

### Use Cases

**Market Research & Pricing Intelligence**
- Track second-hand price curves for iPhones, PS5s, or vintage furniture across UK and ZA monthly snapshots
- Compare regional used-car pricing — same make/model, mileage band, in London vs Manchester vs Cape Town vs Sydney
- Benchmark dealer asking prices against private-seller asking prices on the same model
- Build a "weeks on site" indicator from `postedAt` + `daysOnSite` to flag stale inventory

**Used-Car & Dealer Intelligence**
- Pull every Cars & Vehicles listing across UK, AU, and ZA on a single daily run, segmented by `sellerType`
- Mileage, year, transmission, fuel type, body type, make, model — already broken out under `attributes` for direct CSV column mapping
- Identify dealers running aged stock by joining `sellerName` + `postedAt` over a 30-day window
- Spot pricing anomalies (private listings 20%+ below dealer median for the same car) for arbitrage

**Lead Generation & Outreach**
- Capture seller name and (with `includePhone` on) phone number for direct dealer or seller outreach (best on ZA and AU cars)
- Filter by `sellerType: private` to find homeowners posting "wanted" ads in the For Sale category
- Build region-specific seller directories across the UK and South Africa from the Jobs, Pets, or For Sale catalogues

**Competitive & Reseller Intelligence**
- Watch a competitor's seller name across the UK For Sale category to track their full inventory
- Find arbitrage opportunities — low-price UK listings of items that resell at higher prices on eBay or Vinted
- Monitor new listings in a category every 6 hours by combining `sortBy: Most Recent` with `listingStartDate`
- Identify high-volume sellers (more than 50 active ads) for B2B prospecting

**Journalism & Public-Interest Research**
- Map UK rental-market data across regional postcodes (Property category, beds/baths in `attributes`)
- Track Jobs-category postings by location to surface regional hiring trends
- Quantify second-hand market activity in cost-of-living stories using listing counts and median asking prices

### Getting Started

#### Simple — UK keyword search

```json
{
    "searchKeyword": "iPhone 15",
    "region": "uk",
    "maxResults": 50
}
````

#### South Africa cars with a price range

```json
{
    "searchKeyword": "Toyota Hilux",
    "region": "za",
    "category": "cars-vehicles",
    "minPrice": 100000,
    "maxPrice": 300000,
    "sortBy": "price_low_high",
    "maxResults": 200
}
```

#### UK full-filter run with paste-mode URLs

```json
{
    "startUrls": [
        "https://www.gumtree.com/cars/uk/london",
        "https://www.gumtree.com/flats-houses/uk/manchester?max_price=1200"
    ],
    "searchKeyword": "Ford Focus",
    "region": "uk",
    "location": "Birmingham",
    "category": "cars-vehicles",
    "sortBy": "most_recent",
    "minPrice": 2000,
    "maxPrice": 8000,
    "includeListingDetails": true,
    "includePhone": true,
    "maxResults": 500
}
```

#### Daily incremental monitoring — UK new listings only

Run this every 24 hours with yesterday's date — pagination stops the moment Gumtree returns an ad older than the cutoff, so you only pay for new posts:

```json
{
    "searchKeyword": "MacBook Pro",
    "region": "uk",
    "category": "for-sale",
    "sortBy": "most_recent",
    "listingStartDate": "2026-05-15",
    "maxResults": 0
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | URL\[] | `[]` | Paste Gumtree search, category, or individual listing URLs. Works with gumtree.com (UK), gumtree.com.au (Australia), and gumtree.co.za (South Africa). Mix any combination — the region is detected per URL. Filters in the URL are kept as-is. |
| `searchKeyword` | string | `""` | Keyword to search across Gumtree (e.g. "iPhone 15", "Ford Focus", "2 bed flat"). Combined with the region, location, and category below. Leave blank to browse a whole category or region. |
| `region` | select | `United Kingdom (gumtree.com)` | Which Gumtree region to search when using the keyword/location/category fields. Options: **United Kingdom (gumtree.com)**, **Australia (gumtree.com.au)**, **South Africa (gumtree.co.za)**. Ignored when URLs are pasted — the URL's domain is used instead. |
| `location` | string | `""` | City, town, area, or postcode prefix to narrow the search (e.g. "London", "Perth", "Cape Town", "SW1A"). Leave blank to search the whole region. |
| `category` | select | `All Categories` | Top-level category. Options: **All Categories**, **Cars & Vehicles**, **Property (Houses & Flats)**, **For Sale (Goods)**, **Jobs**, **Pets**, **Community**. Note: Australia is currently supported for **Cars & Vehicles** only; UK and South Africa support every listed category. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | select | `Most Recent` | Listing order. Options: **Most Recent**, **Best Match (Relevance)**, **Price: Low to High**, **Price: High to Low**, **Nearest First**. "Most Recent" is best with the date filter — pagination stops once listings get too old. |
| `minPrice` | integer | `null` | Minimum price in the region's local currency (GBP / AUD / ZAR). Leave blank for no lower bound. |
| `maxPrice` | integer | `null` | Maximum price in the region's local currency (GBP / AUD / ZAR). Leave blank for no upper bound. |
| `listingStartDate` | string | `""` | Only return listings posted on or after this date (YYYY-MM-DD). With sort = Most Recent, the actor stops paginating as soon as it crosses the cutoff. |

#### Output Detail & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum listings to return across all URLs and searches. Set to `0` for unlimited (an internal cap of 50,000 still applies). A single keyword/category search reaches roughly 1,800 rows due to Gumtree's pagination depth — split into multiple `startUrls` to scale beyond that. The run overshoots the final page rather than mid-page-trimming. |
| `includeListingDetails` | boolean | `true` | Open each listing's detail page for full description, all images, structured attributes (beds/baths, mileage/year, etc.), and seller name. Disable for faster, cheaper runs that only return what's on the search-result cards. |
| `includePhone` | boolean | `false` | Include the seller's phone number when Gumtree publishes it in plain sight. Reliable on South Africa and on Australian car listings where the dealer has exposed digits. United Kingdom numbers stay behind a click-to-reveal step, so UK rows always report `phone: null`. Off by default to keep runs fast. |

### Output

Every listing is a flat row with the same 27 fields across UK, AU, and ZA. Here's a representative South African result (Cars & Vehicles, full details enabled):

```json
{
    "listingId": "10013564879631010343222609",
    "shortId": "1356487963",
    "url": "https://www.gumtree.co.za/a-cars-bakkies/durbanville/2008-toyota-rav4-2-0-vx-4x4/10013564879631010343222609",
    "region": "za",
    "title": "2008 Toyota RAV4 2.0 VX 4x4",
    "description": "2008 Toyota RAV4 D4D VX 4WD Manual. 259,000 km. Service history. Black leather interior. Aircon, power steering, central locking, electric windows, alloy wheels...",
    "price": 148700,
    "priceRaw": "R 148,700",
    "currency": "ZAR",
    "priceType": "fixed",
    "category": "Western Cape > Northern Suburbs > Used Automotive Vehicles for Sale > Cars & Bakkies",
    "categorySlug": "9077",
    "location": "Durbanville",
    "postcode": null,
    "latitude": -33.82753,
    "longitude": 18.65268,
    "postedAt": "2026-05-15T09:38:28Z",
    "daysOnSite": 0,
    "sellerName": "Value Auto",
    "sellerType": "business",
    "phone": "0826001533",
    "images": [
        "https://gms.gumtree.co.za/v2/images/za_ads_103432226_260508_69fdf9f4ad21e52aa17698eb?size=l"
    ],
    "imageCount": 1,
    "attributes": {
        "caryear": 2008,
        "cartransmission": "Manual",
        "forsaleby": "Dealer",
        "fueltype": "Petrol",
        "carbodytype": "SUV",
        "carmake": "Toyota",
        "carmodel": "RAV-4",
        "carmileageinkms": 259000,
        "cardrivetype": "4x4"
    },
    "featured": false,
    "urgent": false,
    "scrapedAt": "2026-05-16T08:45:01Z"
}
```

#### Core Identifiers

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | Unique Gumtree listing ID. Stable per region. |
| `shortId` | string | Short numeric ID where Gumtree exposes one (ZA only). `null` on UK and AU. |
| `url` | string | Canonical listing URL on the region's domain. |
| `region` | string | `uk`, `au`, or `za`. |
| `scrapedAt` | string | ISO 8601 UTC timestamp of when the row was captured. |

#### Listing Content

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Listing headline as posted by the seller. |
| `description` | string | Full listing description from the detail page (UK + ZA) or from the search response (AU cars). `null` on UK / ZA when `includeListingDetails` is off. |
| `category` | string | Human-readable category. On UK + ZA detail pages the full breadcrumb (e.g. "Cars & Vehicles > Cars for Sale"); otherwise the top-level category label. |
| `categorySlug` | string | URL-safe category slug or numeric category ID. |
| `images` | string\[] | Every full-resolution image URL on the listing. |
| `imageCount` | integer | Number of images in the listing. |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `price` | integer | Numeric price in the region's local currency (whole units). `null` for free / contact-for-price / swap listings. |
| `priceRaw` | string | Formatted price as it appears on the site (e.g. `"£1,295"`, `"R 148,700"`, `"$5,900"`). |
| `currency` | string | ISO 4217 currency code: `GBP`, `AUD`, or `ZAR`. |
| `priceType` | string | `fixed`, `free`, `swap-trade`, `contact`, or `negotiable`. |

#### Location & Geo

| Field | Type | Description |
|-------|------|-------------|
| `location` | string | Free-text location label (city, suburb, or area). |
| `postcode` | string | Postcode where Gumtree publishes it (mostly ZA detail pages). |
| `latitude` | number | Listing latitude where Gumtree publishes geo data on the detail page. |
| `longitude` | number | Listing longitude where Gumtree publishes geo data on the detail page. |

#### Posted Date

| Field | Type | Description |
|-------|------|-------------|
| `postedAt` | string | ISO 8601 timestamp of when the listing went live (UTC). |
| `daysOnSite` | integer | Whole days between `postedAt` and `scrapedAt`. |

#### Seller

| Field | Type | Description |
|-------|------|-------------|
| `sellerName` | string | Display name of the seller or dealership. |
| `sellerType` | string | `business` (dealer / shop) or `private` (individual). |
| `phone` | string | Seller's published phone number. Populated when `includePhone` is on and the seller has the digits in plain sight (typical on South Africa and Australian car listings). United Kingdom numbers stay behind Gumtree's click-to-reveal step and remain `null`. |

#### Attributes & Flags

| Field | Type | Description |
|-------|------|-------------|
| `attributes` | object | Free-form key-value map of listing-specific fields — `carmake`, `carmodel`, `caryear`, `carmileageinkms`, `cartransmission`, `fueltype`, beds, baths, condition, etc. Keys vary by category. |
| `featured` | boolean | True when the seller has paid for "Featured" placement. |
| `urgent` | boolean | True when the listing carries the "Urgent" badge. |

### Tips for Best Results

- **Daily monitoring? Set `listingStartDate` to yesterday.** With `sortBy: Most Recent`, pagination stops the moment Gumtree returns an ad older than the cutoff — a 24-hour delta run typically costs 5–10% of a full crawl on the same query.
- **Australia coverage focuses on Cars & Vehicles.** UK and South Africa support every category; AU runs default to Cars. If you pick another AU category the run finishes with an actionable hint to either switch region or switch to Cars & Vehicles.
- **Toggle details for speed vs. depth.** Turn off `includeListingDetails` for fast price-only sweeps (titles, prices, locations from search cards). Turn it on for full descriptions, image galleries, structured attributes, and seller names.
- **UK locations accept city names and postcode prefixes.** `London`, `Manchester`, `Birmingham`, `SW1A` resolve to the right region slug. Unknown inputs fall back to a national UK search so the run still returns results.
- **For runs over ~1,800 listings per query, split into multiple `startUrls`.** Gumtree's pagination tops out around 60 pages per search; use two or three category or location URLs in `startUrls` instead of pushing `maxResults` higher on a single search.
- **Use `sortBy: Most Recent` + `listingStartDate` for incremental crawls.** Together they make daily, hourly, or even 15-minute delta runs cheap — only new ads are paginated and charged.
- **Filter by `sellerType` downstream.** `business` vs `private` is captured per row, so a single run can power both a "dealer inventory" report and a "private seller leads" report without re-crawling.
- **Start with `maxResults: 50–100` on a new query.** Confirm titles, prices, and attributes match what you expect, then scale up. Set `maxResults: 0` for the full 50,000-listing cap.

### Pricing

**$1.50 per 1,000 listings** — pay-per-result. You only pay for listings returned to your dataset; there are no compute, run-time, or storage charges from this actor.

| Listings | Cost |
|----------|------|
| 100 | $0.15 |
| 1,000 | $1.50 |
| 10,000 | $15.00 |
| 100,000 | $150.00 |

A "result" is any listing row in the output dataset. Apify platform fees (account plan, storage) may apply separately.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — workflow automation
- **Google Sheets** — direct spreadsheet export
- **Slack** / **Email** — notifications on new results
- **Webhooks** — trigger custom APIs on run completion
- **Apify API** — full programmatic access

### Legal & Ethical Use

This actor extracts publicly visible classified listings for legitimate market research, competitive intelligence, and lead-generation use cases. Users are responsible for complying with applicable laws, Gumtree's Terms of Service, and the GDPR / POPIA / Australian Privacy Act rules that apply in each country. Do not use extracted data for spam, harassment, scraping at volumes that overwhelm the site, or any illegal purpose. Treat seller names, phone numbers, and personal details as personal data — store and process them accordingly.

# Actor input Schema

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

Paste Gumtree search, category, or individual listing URLs. Works with gumtree.com (UK), gumtree.com.au (Australia), and gumtree.co.za (South Africa). Mix any combination - the region is detected per URL. Filters in the URL are kept as-is.

## `searchKeyword` (type: `string`):

Keyword to search across Gumtree (e.g. 'iPhone 15', 'Ford Focus', '2 bed flat'). Combined with the Region, Location, and Category below. Leave blank to browse a whole category or region.

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

Which Gumtree region to search when using the keyword/location/category fields above. Ignored when 'Gumtree URLs' is populated — the URL's domain is used instead.

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

City, town, area, or postcode to narrow the search (e.g. 'London', 'Perth', 'Cape Town', 'SW1A'). Leave blank to search the whole region.

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

Top-level category to search within. The actor maps this to the right slug for each region. Pick 'All Categories' to search across everything. NOTE: Australia is supported for the 'Cars & Vehicles' category only — picking any other category with Region=Australia will return zero results with a hint to switch category or region.

## `sortBy` (type: `string`):

How to order listings. 'Most Recent' is best when combined with the date filter below — pagination stops as soon as listings get too old. 'Nearest First' is only honoured when a Location is set.

## `minPrice` (type: `integer`):

Only include listings priced at or above this amount, in the region's local currency (GBP / AUD / ZAR). Leave blank for no lower bound.

## `maxPrice` (type: `integer`):

Only include listings priced at or below this amount, in the region's local currency (GBP / AUD / ZAR). Leave blank for no upper bound.

## `listingStartDate` (type: `string`):

Only return listings posted on or after this date (YYYY-MM-DD). Most effective with sort 'Most Recent' — the actor stops paginating once it crosses the cutoff, so you don't pay for older rows.

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

Maximum number of listings to return across all URLs and searches. Set to 0 for unlimited (an internal cap of 50,000 still applies). A single keyword/category search reaches roughly 1,800 rows due to Gumtree's pagination depth — split into multiple URLs in 'Gumtree URLs' to scale beyond that. The actor stops requesting new pages once this number is reached but keeps the full final page, so the final count may slightly overshoot. Tip: start with 50–100 to test.

## `includeListingDetails` (type: `boolean`):

Open each listing's page for full description, all images, attributes (beds/baths, mileage/year, etc.), and seller name. Slower but much richer data. Disable for faster, cheaper runs that return only what's on the search-result cards.

## `includePhone` (type: `boolean`):

Include the seller's phone number when Gumtree publishes the digits in plain sight. Best results on South Africa (`gumtree.co.za`) and Australian cars (`gumtree.com.au`), where dealers often expose the full number. United Kingdom (`gumtree.com`) listings keep the last four digits behind a click-to-reveal step that we don't impersonate — the field stays `null` for UK rows rather than returning a masked half-number. Off by default to keep runs fast.

## Actor input object example

```json
{
  "startUrls": [],
  "region": "uk",
  "category": "all",
  "sortBy": "most_recent",
  "maxResults": 100,
  "includeListingDetails": false,
  "includePhone": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped Gumtree listings with title, price, location, posting date, and link.

## `detail` (type: `string`):

All 27 fields per listing — including attributes, images, phone, and geo where Gumtree publishes them.

# 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": [],
    "searchKeyword": "",
    "region": "uk",
    "location": "",
    "category": "all",
    "sortBy": "most_recent",
    "listingStartDate": "",
    "maxResults": 100,
    "includeListingDetails": false,
    "includePhone": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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": [],
    "searchKeyword": "",
    "region": "uk",
    "location": "",
    "category": "all",
    "sortBy": "most_recent",
    "listingStartDate": "",
    "maxResults": 100,
    "includeListingDetails": False,
    "includePhone": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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": [],
  "searchKeyword": "",
  "region": "uk",
  "location": "",
  "category": "all",
  "sortBy": "most_recent",
  "listingStartDate": "",
  "maxResults": 100,
  "includeListingDetails": false,
  "includePhone": false
}' |
apify call solidcode/gumtree-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gumtree Scraper",
        "description": "[💰 $1.5 / 1K] Extract classified listings from Gumtree across the UK, Australia, and South Africa. Get titles, prices, locations, descriptions, images, attributes (beds/baths, mileage/year, etc.), seller info, and contact details for cars, property, jobs, services, and general for-sale items.",
        "version": "1.0",
        "x-build-id": "Z9RVYL9Cl1iuvaXHx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~gumtree-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~gumtree-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~gumtree-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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": "Gumtree URLs",
                        "type": "array",
                        "description": "Paste Gumtree search, category, or individual listing URLs. Works with gumtree.com (UK), gumtree.com.au (Australia), and gumtree.co.za (South Africa). Mix any combination - the region is detected per URL. Filters in the URL are kept as-is.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchKeyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Keyword to search across Gumtree (e.g. 'iPhone 15', 'Ford Focus', '2 bed flat'). Combined with the Region, Location, and Category below. Leave blank to browse a whole category or region."
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "uk",
                            "au",
                            "za"
                        ],
                        "type": "string",
                        "description": "Which Gumtree region to search when using the keyword/location/category fields above. Ignored when 'Gumtree URLs' is populated — the URL's domain is used instead.",
                        "default": "uk"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, town, area, or postcode to narrow the search (e.g. 'London', 'Perth', 'Cape Town', 'SW1A'). Leave blank to search the whole region."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "all",
                            "cars-vehicles",
                            "property",
                            "for-sale",
                            "jobs",
                            "pets",
                            "community"
                        ],
                        "type": "string",
                        "description": "Top-level category to search within. The actor maps this to the right slug for each region. Pick 'All Categories' to search across everything. NOTE: Australia is supported for the 'Cars & Vehicles' category only — picking any other category with Region=Australia will return zero results with a hint to switch category or region.",
                        "default": "all"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "most_recent",
                            "best_match",
                            "price_low_high",
                            "price_high_low",
                            "nearest"
                        ],
                        "type": "string",
                        "description": "How to order listings. 'Most Recent' is best when combined with the date filter below — pagination stops as soon as listings get too old. 'Nearest First' is only honoured when a Location is set.",
                        "default": "most_recent"
                    },
                    "minPrice": {
                        "title": "Minimum Price",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Only include listings priced at or above this amount, in the region's local currency (GBP / AUD / ZAR). Leave blank for no lower bound."
                    },
                    "maxPrice": {
                        "title": "Maximum Price",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Only include listings priced at or below this amount, in the region's local currency (GBP / AUD / ZAR). Leave blank for no upper bound."
                    },
                    "listingStartDate": {
                        "title": "Listings Posted On or After",
                        "type": "string",
                        "description": "Only return listings posted on or after this date (YYYY-MM-DD). Most effective with sort 'Most Recent' — the actor stops paginating once it crosses the cutoff, so you don't pay for older rows."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of listings to return across all URLs and searches. Set to 0 for unlimited (an internal cap of 50,000 still applies). A single keyword/category search reaches roughly 1,800 rows due to Gumtree's pagination depth — split into multiple URLs in 'Gumtree URLs' to scale beyond that. The actor stops requesting new pages once this number is reached but keeps the full final page, so the final count may slightly overshoot. Tip: start with 50–100 to test.",
                        "default": 100
                    },
                    "includeListingDetails": {
                        "title": "Include Full Listing Details",
                        "type": "boolean",
                        "description": "Open each listing's page for full description, all images, attributes (beds/baths, mileage/year, etc.), and seller name. Slower but much richer data. Disable for faster, cheaper runs that return only what's on the search-result cards.",
                        "default": false
                    },
                    "includePhone": {
                        "title": "Include Seller Phone",
                        "type": "boolean",
                        "description": "Include the seller's phone number when Gumtree publishes the digits in plain sight. Best results on South Africa (`gumtree.co.za`) and Australian cars (`gumtree.com.au`), where dealers often expose the full number. United Kingdom (`gumtree.com`) listings keep the last four digits behind a click-to-reveal step that we don't impersonate — the field stays `null` for UK rows rather than returning a masked half-number. Off by default to keep runs fast.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
