# Gumtree Scraper — AU, UK, NZ & South Africa (`muhammadafzal/gumtree-scraper-au-uk-nz-za`) Actor

Search public Gumtree listings across Australia, the UK, and South Africa plus Trade Me New Zealand by URL or keyword. Use for price monitoring and market research; not for accounts or posting ads. Returns normalized listing, price, location, seller, image, and date fields. $0.006/result.

- **URL**: https://apify.com/muhammadafzal/gumtree-scraper-au-uk-nz-za.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** E-commerce, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 listing scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 — AU, UK, NZ & South Africa

**Gumtree Scraper** searches public classified listings by URL or keyword across Gumtree Australia, Gumtree UK, and Gumtree South Africa. It also covers New Zealand through Trade Me, the active New Zealand marketplace, because Gumtree NZ is closed. The actor returns one consistent JSON record per listing so price-monitoring, inventory, market-research, resale, and AI-agent workflows do not need four separate parsers.

Use the Gumtree Scraper when you need public listing titles, prices, locations, descriptions, images, sellers, categories, dates, and marketplace attributes. Do not use it to post ads, log into accounts, send messages, bid, buy, reveal masked contact details, or collect private information. New Zealand data is explicitly identified as `sourcePlatform: "Trade Me"` rather than being presented as Gumtree data.

### What data can I extract with Gumtree Scraper?

| Field | Meaning |
|---|---|
| `listingId` | Stable public marketplace listing identifier |
| `title` | Listing headline |
| `url` | Canonical listing URL |
| `sourcePlatform` | `Gumtree` or `Trade Me` |
| `region` | `uk`, `au`, `nz`, or `za` |
| `price`, `priceText`, `currency` | Numeric price, displayed text, and GBP/AUD/NZD/ZAR currency |
| `location` | Public city, suburb, region, or area |
| `description` | Full detail text or the available search-card excerpt |
| `category` | Marketplace category or breadcrumb path |
| `sellerName`, `sellerType` | Public seller display information when available |
| `postedAt` | Exact timestamp or marketplace listing age when exposed |
| `imageUrl`, `images` | Primary image and public image gallery |
| `attributes` | Category facts such as condition, make, model, mileage, or bedrooms |
| `sourceUrl`, `searchKeyword`, `scrapedAt` | Reproducibility and freshness metadata |

Every record keeps the same keys. Missing public fields are returned as `null`, empty arrays, or empty objects instead of disappearing from the schema. This stable shape is suitable for Apify API clients and MCP agents.

### Use cases for Gumtree and Trade Me data

- Compare used-car, electronics, property, furniture, or bicycle prices across cities.
- Monitor newly listed inventory and identify underpriced resale opportunities.
- Build public marketplace datasets for category or regional market research.
- Track dealer versus private-seller supply when the marketplace publishes seller type.
- Feed structured listings into spreadsheets, databases, dashboards, alerts, or RAG systems.
- Give an AI agent a narrow URL-or-keyword tool with predictable output and billing.

The actor only processes publicly visible listing information. It does not bypass account controls or provide private seller contact data.

### How much will scraping Gumtree cost?

This actor uses transparent pay-per-event pricing.

| Event | Price |
|---|---:|
| Actor start | $0.00005 per run, scaled by memory |
| Listing scraped | $0.006 per dataset record |

Examples:

- 1 listing costs about **$0.00605**.
- 20 listings cost about **$0.12005**.
- 100 listings cost about **$0.60005**.
- 500 listings cost about **$3.00005**.

`maxResults` is a strict total cap across every URL, keyword, and region. The actor displays the maximum listing-event cost before scraping and stops when the Apify charge or paid-dataset cap is reached. Failed pages, filtered listings, duplicate listings, and listings that cannot be written to the dataset are not charged as result events. Apify compute and residential proxy usage may be billed by the platform according to the caller's plan.

### How to use Gumtree Scraper

Choose either mode or combine them:

1. Paste Gumtree AU/UK/ZA or Trade Me NZ search, category, or individual listing URLs into `startUrls`.
2. Add keyword phrases to `keywords` and select one or more `regions`.
3. Optionally filter the extracted public location or local-currency price.
4. Enable `includeDetails` when you need full descriptions, galleries, sellers, dates, categories, and attributes; the fast default is search-card output.
5. Set `responseFormat: "concise"` for smaller AI-agent output, or keep `detailed` for full records.
6. Set `maxResults` to control the billable result ceiling.

When multiple searches are supplied, the actor allocates the total result cap across them. This prevents the first country or keyword from consuming the whole budget.

#### Search all four regions by keyword

```json
{
  "keywords": ["mountain bike"],
  "regions": ["uk", "au", "nz", "za"],
  "includeDetails": true,
  "responseFormat": "detailed",
  "maxResults": 40
}
````

#### Search by copied URLs

```json
{
  "startUrls": [
    { "url": "https://www.gumtree.com/search?q=bicycle" },
    { "url": "https://www.gumtree.co.za/s-bicycles/v1q0p1" },
    { "url": "https://www.trademe.co.nz/a/marketplace/search?search_string=bicycle" }
  ],
  "keywords": [],
  "includeDetails": false,
  "maxResults": 30
}
```

#### Filter normalized output

```json
{
  "keywords": ["Ford Ranger"],
  "regions": ["au"],
  "location": "Perth",
  "minPrice": 5000,
  "maxPrice": 35000,
  "maxResults": 50
}
```

Price bounds use the selected marketplace's local currency. They do not convert GBP, AUD, NZD, and ZAR into a common currency.

### Output example

```json
{
  "listingId": "1800256072",
  "title": "Women bicycle free to collect",
  "url": "https://www.gumtree.com/p/city-bikes/example/1800256072",
  "sourceUrl": "https://www.gumtree.com/search?q=bicycle",
  "sourcePlatform": "Gumtree",
  "region": "uk",
  "searchKeyword": "bicycle",
  "description": "Public listing description...",
  "price": 0,
  "priceText": "£0",
  "currency": "GBP",
  "location": "Bristol",
  "category": "For Sale > Bicycles > City Bikes",
  "sellerName": null,
  "sellerType": "private",
  "postedAt": "0 days",
  "imageUrl": "https://img.gumtree.com/example/640",
  "images": ["https://img.gumtree.com/example/640"],
  "attributes": { "Condition": "Used" },
  "isFeatured": false,
  "scrapedAt": "2026-07-13T10:15:30.000Z",
  "warnings": []
}
```

The `OUTPUT` key in the run's default key-value store contains counts, regions, source URLs, warnings, billing totals, and the dataset ID. Partial detail-page failures preserve valid search-card records with a warning rather than discarding the whole batch.

### API and MCP examples

JavaScript with the Apify client:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('muhammadafzal/gumtree-scraper-au-uk-nz-za').call({
  keywords: ['vintage bicycle'],
  regions: ['uk', 'nz'],
  maxResults: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("muhammadafzal/gumtree-scraper-au-uk-nz-za").call(run_input={
    "keywords": ["vintage bicycle"],
    "regions": ["uk", "nz"],
    "maxResults": 20,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

Through Apify MCP, add `muhammadafzal/gumtree-scraper-au-uk-nz-za`, call the actor with the same JSON input, then page through the dataset with `get-actor-output`.

### Reliability and marketplace limits

Gumtree Australia and Trade Me actively reject some datacenter and automated sessions. Cloud browser runs therefore use country-matched Apify residential proxies, persistent cookies, stable browser fingerprints, stealth hardening, session warmup, retries, and challenge detection. Gumtree AU currently blocks direct cloud browser sessions consistently, so its public pages are read through the unauthenticated Jina Reader endpoint first; every such row is explicitly labeled in `warnings`. If that reader is unavailable, the actor retries Gumtree through the browser path. Trade Me NZ is read directly and uses the browser safeguards above.

Marketplaces can remove listings, omit fields, change markup, or show different data by region. A deleted individual listing is skipped with a warning. Valid searches with no matches complete normally. If every request is blocked after all retries, the actor fails honestly with an actionable terminal message instead of pretending an empty dataset is successful.

### Other dedicated scrapers

- [Craigslist Scraper](https://apify.com/muhammadafzal/craigslist-scraper)
- [eBay Scraper](https://apify.com/muhammadafzal/ebay-scraper)
- [AutoScout24 Scraper](https://apify.com/muhammadafzal/autoscout24-scraper)
- [Google Shopping Scraper](https://apify.com/muhammadafzal/google-shopping-scraper)
- [Google Maps Scraper](https://apify.com/muhammadafzal/google-maps-scraper)
- [Google Maps Restaurant Scraper](https://apify.com/muhammadafzal/google-maps-restaurant-scraper)
- [Domain Scraper](https://apify.com/muhammadafzal/domain-scraper)
- [AI Web Extractor](https://apify.com/muhammadafzal/ai-web-extractor)
- [StepStone Jobs Scraper](https://apify.com/muhammadafzal/stepstone-jobs-scraper)
- [Skyscanner Flight Scraper](https://apify.com/muhammadafzal/skyscanner-flight-scraper)

### FAQ

#### How many results can I scrape with Gumtree Scraper?

Each run can return 1 to 500 listings. Large monitoring jobs should use narrow URLs or keywords and schedules so costs and changes remain easy to audit.

#### Can I integrate Gumtree Scraper with other apps?

Yes. Export JSON, CSV, Excel, XML, or RSS, or connect the dataset to webhooks, Make, Zapier, n8n, Google Sheets, databases, and cloud storage.

#### Can I use Gumtree Scraper with the Apify API?

Yes. The actor accepts the same input through Console, API, CLI, schedules, Tasks, and integrations.

#### Can I use Gumtree Scraper through an MCP Server?

Yes. Add the actor to Apify's hosted MCP server. Its schema is optimized for tool selection, predictable inputs, consistent records, and paginated output.

#### Do I need proxies to scrape Gumtree or Trade Me?

Cloud runs configure country-matched Apify residential proxies automatically. Users do not need to paste proxy credentials or cookies into actor input.

#### Is it legal to scrape Gumtree and Trade Me data?

This actor extracts publicly visible information. Laws and marketplace terms vary by jurisdiction and use case. You are responsible for ensuring a lawful basis, respecting applicable privacy, database, consumer, and intellectual-property rules, limiting request volume, and complying with Gumtree, Trade Me, Apify, GDPR, the Australian Privacy Act, New Zealand Privacy Act, and South Africa POPIA where applicable. Do not use results for spam, harassment, discrimination, or unlawful profiling.

#### Your feedback

Report a failing public URL, unexpected field, or reproducible output issue through the actor's Issues tab. Include the run ID and input with secrets removed.

# Actor input Schema

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

Use this when you already have Gumtree AU/UK/ZA or Trade Me NZ search, category, or listing URLs. Accepts request objects such as {"url":"https://www.gumtree.com/search?q=bicycle"}. Defaults to an empty list. This is not for seller account, message, or posting-ad URLs.

## `keywords` (type: `array`):

Use this when you want the actor to create marketplace searches for you. Enter one phrase per line, for example "mountain bike" or "Ford Ranger". Defaults to \["bicycle"]. This is not a URL field; paste URLs into Search or Listing URLs.

## `regions` (type: `array`):

Use this to choose where each keyword is searched. Accepted values are uk, au, nz, and za; New Zealand routes to Trade Me because Gumtree NZ is closed. Defaults to \["uk"]. This does not override the country encoded in a supplied URL.

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

Use this to retain listings whose displayed location contains a city, region, or postcode, for example "London" or "Auckland". Matching is case-insensitive after extraction. Defaults to an empty string, which keeps every location. This is not a radius or latitude/longitude filter.

## `minPrice` (type: `number`):

Use this to exclude listings below a numeric price in each marketplace's local currency, for example 100. Set 0 to disable the minimum. Defaults to 0 and must be non-negative. This is not currency conversion; GBP, AUD, NZD, and ZAR remain separate.

## `maxPrice` (type: `number`):

Use this to exclude listings above a numeric price in each marketplace's local currency, for example 5000. Set 0 to disable the maximum. Defaults to 0 and must be non-negative. This is not a global converted-price ceiling across currencies.

## `includeDetails` (type: `boolean`):

Enable this to visit each listing page for full descriptions, image galleries, sellers, categories, dates, and attributes. It defaults to false for a fast, reliable search. This does not reveal private, login-only, masked, or unpublished seller data.

## `responseFormat` (type: `string`):

Use concise for smaller AI-agent responses or detailed for full descriptions, images, and attributes. Accepted values are concise and detailed. Defaults to detailed. This changes record richness, not which listings are discovered.

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

Use this to cap the total billable listings across all URLs, keywords, and regions. Enter 1 to 500; for example 20 costs at most $0.12 in listing events. Defaults to 20. This is not a per-keyword limit; the actor allocates the total fairly across searches.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.gumtree.com/search?q=bicycle"
    }
  ],
  "keywords": [
    "bicycle"
  ],
  "regions": [
    "uk",
    "au",
    "nz",
    "za"
  ],
  "location": "",
  "minPrice": 0,
  "maxPrice": 0,
  "includeDetails": false,
  "responseFormat": "detailed",
  "maxResults": 20
}
```

# Actor output Schema

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

Dataset records with listing identity, price, location, description, seller, images, attributes, region, source platform, and timestamps.

## `summary` (type: `string`):

Machine-readable counts, regions, warnings, cost, and completion information for this run.

# 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?q=bicycle"
        }
    ],
    "keywords": [
        "bicycle"
    ],
    "regions": [
        "uk",
        "au",
        "nz",
        "za"
    ],
    "location": "",
    "includeDetails": false,
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/gumtree-scraper-au-uk-nz-za").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?q=bicycle" }],
    "keywords": ["bicycle"],
    "regions": [
        "uk",
        "au",
        "nz",
        "za",
    ],
    "location": "",
    "includeDetails": False,
    "maxResults": 20,
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.gumtree.com/search?q=bicycle"
    }
  ],
  "keywords": [
    "bicycle"
  ],
  "regions": [
    "uk",
    "au",
    "nz",
    "za"
  ],
  "location": "",
  "includeDetails": false,
  "maxResults": 20
}' |
apify call muhammadafzal/gumtree-scraper-au-uk-nz-za --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gumtree Scraper — AU, UK, NZ & South Africa",
        "description": "Search public Gumtree listings across Australia, the UK, and South Africa plus Trade Me New Zealand by URL or keyword. Use for price monitoring and market research; not for accounts or posting ads. Returns normalized listing, price, location, seller, image, and date fields. $0.006/result.",
        "version": "1.0",
        "x-build-id": "HSVdpNtZV871AJtSd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/muhammadafzal~gumtree-scraper-au-uk-nz-za/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-muhammadafzal-gumtree-scraper-au-uk-nz-za",
                "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/muhammadafzal~gumtree-scraper-au-uk-nz-za/runs": {
            "post": {
                "operationId": "runs-sync-muhammadafzal-gumtree-scraper-au-uk-nz-za",
                "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/muhammadafzal~gumtree-scraper-au-uk-nz-za/run-sync": {
            "post": {
                "operationId": "run-sync-muhammadafzal-gumtree-scraper-au-uk-nz-za",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Search or Listing URLs",
                        "type": "array",
                        "description": "Use this when you already have Gumtree AU/UK/ZA or Trade Me NZ search, category, or listing URLs. Accepts request objects such as {\"url\":\"https://www.gumtree.com/search?q=bicycle\"}. Defaults to an empty list. This is not for seller account, message, or posting-ad URLs.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keywords": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Use this when you want the actor to create marketplace searches for you. Enter one phrase per line, for example \"mountain bike\" or \"Ford Ranger\". Defaults to [\"bicycle\"]. This is not a URL field; paste URLs into Search or Listing URLs.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "bicycle"
                        ]
                    },
                    "regions": {
                        "title": "Marketplace Regions",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Use this to choose where each keyword is searched. Accepted values are uk, au, nz, and za; New Zealand routes to Trade Me because Gumtree NZ is closed. Defaults to [\"uk\"]. This does not override the country encoded in a supplied URL.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "uk",
                                "au",
                                "nz",
                                "za"
                            ],
                            "enumTitles": [
                                "United Kingdom — Gumtree",
                                "Australia — Gumtree",
                                "New Zealand — Trade Me",
                                "South Africa — Gumtree"
                            ]
                        },
                        "default": [
                            "uk"
                        ]
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Use this to retain listings whose displayed location contains a city, region, or postcode, for example \"London\" or \"Auckland\". Matching is case-insensitive after extraction. Defaults to an empty string, which keeps every location. This is not a radius or latitude/longitude filter.",
                        "default": ""
                    },
                    "minPrice": {
                        "title": "Minimum Price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Use this to exclude listings below a numeric price in each marketplace's local currency, for example 100. Set 0 to disable the minimum. Defaults to 0 and must be non-negative. This is not currency conversion; GBP, AUD, NZD, and ZAR remain separate.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum Price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Use this to exclude listings above a numeric price in each marketplace's local currency, for example 5000. Set 0 to disable the maximum. Defaults to 0 and must be non-negative. This is not a global converted-price ceiling across currencies.",
                        "default": 0
                    },
                    "includeDetails": {
                        "title": "Enrich Listing Details",
                        "type": "boolean",
                        "description": "Enable this to visit each listing page for full descriptions, image galleries, sellers, categories, dates, and attributes. It defaults to false for a fast, reliable search. This does not reveal private, login-only, masked, or unpublished seller data.",
                        "default": false
                    },
                    "responseFormat": {
                        "title": "Response Detail Level",
                        "enum": [
                            "concise",
                            "detailed"
                        ],
                        "type": "string",
                        "description": "Use concise for smaller AI-agent responses or detailed for full descriptions, images, and attributes. Accepted values are concise and detailed. Defaults to detailed. This changes record richness, not which listings are discovered.",
                        "default": "detailed"
                    },
                    "maxResults": {
                        "title": "Maximum Total Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Use this to cap the total billable listings across all URLs, keywords, and regions. Enter 1 to 500; for example 20 costs at most $0.12 in listing events. Defaults to 20. This is not a per-keyword limit; the actor allocates the total fairly across searches.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
