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

Scrape listings from Gumtree Australia (.com.au), Gumtree UK (.com), and Gumtree South Africa (.co.za). Extract titles, prices, descriptions, images, seller info, location, and more from search results and individual listing pages.

- **URL**: https://apify.com/crawlerbros/gumtree-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Real estate, E-commerce, Other
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 17 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Scraper

Scrape listings from **Gumtree Australia** (.com.au), **Gumtree UK** (.com), and **Gumtree South Africa** (.co.za). Extract structured data including titles, prices, descriptions, images, seller information, location, attributes, and more from search results and individual listing pages.

### Features

- Scrapes **3 Gumtree domains**: Australia, UK, and South Africa
- Extracts data from **search result pages** and **individual listing pages**
- Supports **pagination** — automatically follows multiple pages up to your limit
- Extracts **rich listing details** including descriptions, all images, seller info, and category-specific attributes
- **No browser required** — uses lightweight HTTP requests for fast, cost-effective scraping
- Handles **rate limiting** and retries automatically

### Supported Domains

| Domain | URL Pattern | Example |
|--------|-------------|---------|
| Gumtree Australia | `gumtree.com.au` | `https://www.gumtree.com.au/s-cars-vans-utes/c18320` |
| Gumtree UK | `gumtree.com` | `https://www.gumtree.com/search?q=laptop` |
| Gumtree South Africa | `gumtree.co.za` | `https://www.gumtree.co.za/s-cars-bakkies/v1c9077p1` |

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `startUrls` | Array | **Yes** | — | URLs to scrape. Can be search result pages or individual listing pages from any supported Gumtree domain. |
| `maxItems` | Integer | No | `100` | Maximum number of listings to scrape per start URL. |
| `includeListingDetails` | Boolean | No | `true` | Whether to visit each listing page for full details (description, all images, seller info). Disable for faster but less detailed scraping. |
| `cookies` | Array | No | `[]` | Browser cookies (EditThisCookie format) for Gumtree Australia bypass. Required for AU due to Akamai bot protection. |
| `proxy` | Object | No | Apify Residential | Proxy configuration. Residential proxies are required for Australian domain. |

### Architecture

The scraper automatically detects the domain from your URL and routes requests accordingly:

- **UK (.com) and ZA (.co.za)** → Fast HTTP requests with httpx (no browser needed)
- **AU (.com.au)** → Browser-fingerprinted requests with impit, falling back to Playwright with stealth

This hybrid approach keeps costs low for UK/ZA while providing browser emulation where needed for AU.

### Input Example

```json
{
    "startUrls": [
        { "url": "https://www.gumtree.com/search?q=bicycle" },
        { "url": "https://www.gumtree.co.za/s-cars-bakkies/v1c9077p1" }
    ],
    "maxItems": 50,
    "includeListingDetails": true,
    "proxy": {
        "useApifyProxy": true
    }
}
````

### Output Fields

| Field | Type | Description |
|-------|------|-------------|
| `adId` | String | Unique listing identifier |
| `title` | String | Listing title |
| `description` | String | Full listing description (text only) |
| `price` | String | Price amount |
| `currency` | String | Currency code (GBP, AUD, ZAR) |
| `priceType` | String | Price type (FIXED, NEGOTIABLE, CONTACT\_ME, MAKE\_OFFER) |
| `location` | String | Location name |
| `latitude` | Number | GPS latitude (when available) |
| `longitude` | Number | GPS longitude (when available) |
| `category` | String | Listing category |
| `imageUrl` | String | Primary image URL |
| `images` | Array | All image URLs |
| `sellerName` | String | Seller/dealer name |
| `sellerType` | String | Seller type (Private, Trade, Dealer) |
| `postedDate` | String | When the listing was posted |
| `attributes` | Object | Category-specific attributes (e.g., car make, year, mileage, condition) |
| `link` | String | Direct URL to the listing |
| `sourceUrl` | String | The start URL this listing was found from |
| `domain` | String | Domain identifier (au, uk, za) |
| `extractedAt` | String | ISO timestamp of when data was extracted |

### Output Example

```json
{
    "adId": "1511110656",
    "title": "HP i7 32GB Ram 2TB SSD High Spec Laptop NVIDIA RTX 4GB",
    "description": "HP ZBook Studio i7 11th Gen...",
    "price": "650.00",
    "currency": "GBP",
    "priceType": "",
    "location": "Sunderland, Tyne and Wear",
    "latitude": null,
    "longitude": null,
    "category": "PC Laptops & Netbooks",
    "imageUrl": "https://img.gumtree.com/...",
    "images": ["https://img.gumtree.com/..."],
    "sellerName": "JUNIOR",
    "sellerType": "Trade",
    "postedDate": "13 days",
    "attributes": {
        "Condition": "As good as new"
    },
    "link": "https://www.gumtree.com/p/laptops/hp-i7-laptop/1511110656",
    "sourceUrl": "https://www.gumtree.com/search?q=laptop",
    "domain": "uk",
    "extractedAt": "2026-04-04T06:40:25.164694+00:00"
}
```

### How to Use

1. **Go to the Gumtree Scraper** actor page on Apify
2. **Add Start URLs** — paste one or more Gumtree search or listing URLs
3. **Set Max Items** — choose how many listings you want per URL
4. **Run the actor** — results appear in the Dataset tab
5. **Export data** — download as JSON, CSV, Excel, or connect via API

### URL Types

#### Search URLs

Navigate to any Gumtree search page and copy the URL:

- **UK**: `https://www.gumtree.com/search?q=laptop&max_price=500`
- **AU**: `https://www.gumtree.com.au/s-cars-vans-utes/perth/c18320l3008303`
- **ZA**: `https://www.gumtree.co.za/s-cars-bakkies/v1c9077p1`

#### Individual Listing URLs

Copy the URL of any individual listing:

- **UK**: `https://www.gumtree.com/p/laptops/my-laptop/1511110656`
- **AU**: `https://www.gumtree.com.au/s-ad/sydney/cars/my-car/1341427739`
- **ZA**: `https://www.gumtree.co.za/a-cars/pretoria/my-car/10013428956741013052980009`

### Proxy Configuration

- **UK and ZA** domains work reliably with standard Apify proxy (or without proxy)
- **AU domain** requires residential proxies and may need user-provided session cookies due to Akamai Bot Manager protection

#### How to get AU cookies (optional but recommended)

1. Open Gumtree Australia in your browser: https://www.gumtree.com.au
2. Install the [EditThisCookie](https://chrome.google.com/webstore/detail/editthiscookie/fngmhnnpilhplaeedifhccceomclgfbg) Chrome extension
3. Click the extension icon and click "Export"
4. Paste the JSON cookies array into the `cookies` input field

### FAQ

**Q: Which Gumtree domains are supported?**
A: Gumtree Australia (.com.au), Gumtree UK (.com), and Gumtree South Africa (.co.za).

**Q: Can I scrape multiple domains in one run?**
A: Yes! Add URLs from different domains to the Start URLs array. The scraper automatically detects the domain.

**Q: Why are some fields empty?**
A: Field availability varies by domain and listing type. UK listings may not have latitude/longitude. Some sellers don't provide all details. Setting `includeListingDetails: true` maximizes data completeness.

**Q: How fast is the scraper?**
A: The scraper uses HTTP requests (no browser), making it very fast. With `includeListingDetails: false`, it can process hundreds of listings per minute. With details enabled, it's limited by the 1-second delay between detail page requests.

**Q: Do I need a proxy?**
A: For UK and South Africa, the scraper works without proxy. Australia has strong anti-bot protection and may not work with HTTP-only requests — a browser-based approach may be needed for AU.

**Q: What is the `attributes` field?**
A: This contains category-specific details. For cars, it may include Year, Mileage, Fuel Type, etc. For electronics, it may include Condition, Brand, etc. The available attributes depend on the listing category.

# Actor input Schema

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

URLs to scrape. Supports Gumtree AU (.com.au), UK (.com), and ZA (.co.za). Can be search result pages or individual listing pages.

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

Maximum number of listings to scrape per start URL.

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

Whether to visit each listing page for full details (description, all images, seller info). Disable for faster but less detailed scraping.

## `cookies` (type: `array`):

Optional cookies for Gumtree Australia. AU uses Akamai Bot Manager which blocks most proxies. Provide your browser's Gumtree AU cookies (export via EditThisCookie extension) to bypass detection. Not needed for UK/ZA.

## `proxy` (type: `object`):

Proxy settings. For Gumtree Australia (.com.au), residential proxies are required to bypass Akamai bot protection. UK and ZA work with default Apify proxy.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.gumtree.co.za/s-cars-bakkies/c9077"
    }
  ],
  "maxItems": 5,
  "includeListingDetails": true,
  "cookies": [],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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.co.za/s-cars-bakkies/c9077"
        }
    ],
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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.co.za/s-cars-bakkies/c9077" }],
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/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.co.za/s-cars-bakkies/c9077"
    }
  ],
  "maxItems": 5
}' |
apify call crawlerbros/gumtree-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gumtree Scraper",
        "description": "Scrape listings from Gumtree Australia (.com.au), Gumtree UK (.com), and Gumtree South Africa (.co.za). Extract titles, prices, descriptions, images, seller info, location, and more from search results and individual listing pages.",
        "version": "1.0",
        "x-build-id": "JqsnyXLKDkbdEMwJL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~gumtree-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-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/crawlerbros~gumtree-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-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/crawlerbros~gumtree-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "URLs to scrape. Supports Gumtree AU (.com.au), UK (.com), and ZA (.co.za). Can be search result pages or individual listing pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape per start URL.",
                        "default": 100
                    },
                    "includeListingDetails": {
                        "title": "Include Listing Details",
                        "type": "boolean",
                        "description": "Whether to visit each listing page for full details (description, all images, seller info). Disable for faster but less detailed scraping.",
                        "default": true
                    },
                    "cookies": {
                        "title": "Cookies (for AU bypass)",
                        "type": "array",
                        "description": "Optional cookies for Gumtree Australia. AU uses Akamai Bot Manager which blocks most proxies. Provide your browser's Gumtree AU cookies (export via EditThisCookie extension) to bypass detection. Not needed for UK/ZA.",
                        "default": []
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. For Gumtree Australia (.com.au), residential proxies are required to bypass Akamai bot protection. UK and ZA work with default Apify proxy.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
