# OfferUp Marketplace Listings Scraper (`automation-lab/offerup-marketplace-listings-scraper`) Actor

Search public OfferUp US marketplace listings by keyword, ZIP, filters, or search URL. Export prices, locations, conditions, delivery flags, images, IDs, and listing URLs without login.

- **URL**: https://apify.com/automation-lab/offerup-marketplace-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

## OfferUp Marketplace Listings Scraper

Search OfferUp and export public US marketplace listings as clean JSON, CSV, Excel, XML, or RSS.

Enter product keywords or OfferUp search URLs, choose a ZIP code and filters, and receive listing IDs, titles, prices, locations, conditions, pickup and shipping signals, images, firm-price signals, price-drop signals, and vehicle mileage when OfferUp provides them.

No OfferUp login, cookies, or user account is required.

### What does OfferUp Marketplace Listings Scraper do?

The Actor turns OfferUp search results into structured records that are ready for spreadsheets, dashboards, databases, and monitoring jobs.

It can:

- 🔎 search several keywords in one run;
- 📍 target a five-digit US ZIP code and radius;
- 🏷️ apply an OfferUp category identifier;
- 💵 constrain minimum and maximum price;
- 📦 select local pickup or shipping inventory;
- 🧰 filter verified listing conditions;
- ↕️ sort by relevance, recency, distance, or price;
- 🔁 follow OfferUp pagination cursors;
- 🧹 remove duplicate listing IDs across searches.

The result limit applies globally, so a run never intentionally saves more listings than requested.

### Who is it for?

#### Resellers and arbitrage teams

Find newly listed local inventory, compare asking prices, and feed promising deals into sourcing workflows.

#### Dealers and inventory buyers

Track vehicles, tools, electronics, furniture, or other local stock around selected markets.

#### Market researchers

Capture scheduled snapshots for price distribution, assortment, availability, and geographic analysis.

#### Developers and data teams

Use stable fields and canonical item URLs in internal lead pipelines, alerts, enrichment jobs, or BI systems.

### Why use this OfferUp scraper?

Manual OfferUp searching is useful for one-off browsing but difficult to repeat across many keywords or cities.

This Actor adds:

- repeatable input and output contracts;
- cursor pagination beyond the first visible screen;
- exact ID deduplication;
- local validation of price, condition, and delivery filters;
- retries and session rotation for transient blocking;
- Apify scheduling, webhooks, datasets, API access, and integrations.

It only exports public listing-search information and does not automate messaging or accounts.

### How to scrape OfferUp listings

1. Open the Actor input page.
2. Add one or more search keywords, such as `iphone` or `Toyota Tacoma`.
3. Enter a US ZIP code and radius.
4. Optionally choose price, condition, delivery, category, and sort filters.
5. Set a small `maxItems` value for the first run.
6. Click **Start**.
7. Open the default dataset to preview or download the results.

For an existing OfferUp search, paste its `/search` or `/explore` URL into `startUrls`.

### Input

| Field | Type | Purpose |
|---|---|---|
| `keywords` | string array | Product, brand, or vehicle searches |
| `startUrls` | URL array | OfferUp search or explore URLs |
| `zipCode` | string | Five-digit US ZIP code |
| `radius` | integer | 5, 10, 20, 30, or 50 miles |
| `categoryId` | string | Optional OfferUp category identifier |
| `minPrice` | number | Inclusive minimum USD price |
| `maxPrice` | number | Inclusive maximum USD price |
| `conditions` | string array | New, open box, refurbished, used, or broken |
| `delivery` | string | All, local pickup, or shipping |
| `sortBy` | string | Relevance, recent, closest, low price, or high price |
| `maxItems` | integer | Global unique listing limit |
| `maxRequestRetries` | integer | Attempts per page on transient blocks |

Provide at least one keyword or start URL.

Invalid ZIP codes, non-OfferUp URLs, impossible price ranges, and unsupported target paths fail early.

### Example input

```json
{
  "keywords": ["iphone", "macbook pro"],
  "zipCode": "90001",
  "radius": 30,
  "minPrice": 50,
  "maxPrice": 1000,
  "delivery": "all",
  "sortBy": "recent",
  "maxItems": 40
}
````

A URL-based run can use:

```json
{
  "startUrls": [
    { "url": "https://offerup.com/search?q=mountain+bike" }
  ],
  "zipCode": "98101",
  "radius": 20,
  "maxItems": 25
}
```

### Output data

Each dataset row represents one OfferUp listing.

| Field | Description |
|---|---|
| `listingId` | Stable OfferUp listing identifier |
| `url` | Canonical OfferUp item URL |
| `title` | Listing title |
| `price` | Numeric asking price when available |
| `formattedPrice` | Display-ready price |
| `currency` | `USD` |
| `locationName` | Public listing location |
| `condition` | OfferUp condition label when available |
| `flags` | Source fulfillment or listing flags |
| `localPickup` | Local pickup signal |
| `shippingAvailable` | Shipping signal |
| `imageUrl` | Primary OfferUp image |
| `imageWidth` / `imageHeight` | Source image dimensions |
| `isFirmPrice` | Firm-price signal when supplied |
| `priceDrop` | Price-drop signal when supplied |
| `vehicleMiles` | Vehicle mileage when supplied |
| `searchQuery` | Keyword that produced the listing |
| `sourceUrl` | Search URL used by the Actor |
| `scrapedAt` | UTC extraction timestamp |

### Example output

```json
{
  "listingId": "54d2d5da-db7e-327a-a426-335d3b599f8f",
  "url": "https://offerup.com/item/detail/54d2d5da-db7e-327a-a426-335d3b599f8f",
  "title": "Apple iPhone",
  "price": 250,
  "formattedPrice": "$250",
  "currency": "USD",
  "locationName": "Los Angeles, CA",
  "condition": null,
  "flags": ["LOCAL_PICKUP"],
  "localPickup": true,
  "shippingAvailable": false,
  "imageUrl": "https://images.offerup.com/example.jpg",
  "vehicleMiles": null,
  "searchQuery": "iphone",
  "scrapedAt": "2026-07-24T00:00:00.000Z"
}
```

Nullable fields mean OfferUp did not provide that signal in the search feed.

### How much does it cost to scrape OfferUp listings?

The Actor uses pay-per-event pricing.

- Run start: **$0.005**
- BRONZE listing price: **$0.00012807 per saved listing**
- Higher Apify plans receive tiered volume discounts.

A 20-listing BRONZE run is approximately $0.0076 before any platform-specific limits or credits.

The dataset contains only charged, saved listings. Use `maxItems` to keep test and scheduled runs predictable.

### Filters and fail-closed behavior

OfferUp may omit condition or fulfillment information from an individual search tile.

When you request a condition, local pickup, shipping, or numeric price boundary, the Actor keeps only records that can be verified against that boundary.

It does not guess missing values.

This avoids silently returning listings that violate a buyer workflow.

### Pagination and deduplication

OfferUp returns an opaque cursor with each search feed.

The Actor replays that cursor with the same search session and stops when:

- `maxItems` is reached;
- the source returns no listing tiles;
- no new cursor is available;
- a cursor repeats;
- the run charge limit is reached.

Listing IDs are deduplicated across all keywords and URLs in the run.

### Scheduling an OfferUp monitor

Use an Apify schedule to run the same search hourly, daily, or weekly.

Recommended monitoring pattern:

1. sort by recent listings;
2. keep `maxItems` proportional to expected new inventory;
3. store listing IDs in your destination system;
4. treat unseen IDs as new inventory;
5. send a webhook when the run succeeds.

The Actor itself returns current snapshots; long-term change history belongs in your database or automation flow.

### Integrations

#### Google Sheets

Connect the run dataset to Sheets for sourcing queues and price review.

#### Make and Zapier

Trigger workflows from completed runs, then route new listing IDs to Slack, email, Airtable, or a CRM.

#### Webhooks

Receive run-completion events and fetch the dataset through the Apify API.

#### Cloud storage and BI

Export JSON or CSV into S3, BigQuery, Snowflake, Power BI, or another analytics stack.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/offerup-marketplace-listings-scraper').call({
  keywords: ['iphone'],
  zipCode: '90001',
  radius: 30,
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/offerup-marketplace-listings-scraper').call(run_input={
    'keywords': ['mountain bike'],
    'zipCode': '98101',
    'radius': 20,
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~offerup-marketplace-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["gaming laptop"],"zipCode":"10001","radius":20,"maxItems":20}'
```

Fetch dataset items after the run succeeds:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Use with Apify MCP

#### Claude Code setup

```bash
claude mcp add --transport http apify https://mcp.apify.com?tools=automation-lab/offerup-marketplace-listings-scraper
```

#### Claude Desktop, Cursor, and VS Code setup

Add this MCP JSON block to the appropriate Claude Desktop, Cursor, or VS Code MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/offerup-marketplace-listings-scraper"
    }
  }
}
```

Authenticate with your Apify account when prompted.

Example prompts:

- “Run the OfferUp listings scraper for used camera lenses near ZIP 94103.”
- “Export 30 recent Toyota Tacoma listings and summarize the asking prices.”
- “Find local-pickup power tools under $300 around Dallas.”

### Tips for reliable runs

- Start with 10–20 listings while validating a new market.
- Use specific phrases to reduce irrelevant inventory.
- Use a larger radius for sparse products.
- Avoid many broad keywords in one run when one focused query is enough.
- Leave retries at the default unless logs show repeated transient blocks.
- Schedule recent-first searches for inventory monitoring.
- Use canonical `listingId` values for downstream deduplication.

### Limitations

OfferUp is an evolving marketplace and can change its public feed or anti-bot controls.

The Actor uses US residential sessions because direct datacenter access may be blocked.

Search tiles do not always include condition, shipping, firm-price, price-drop, or mileage values.

V1 does not claim descriptions, full galleries, seller ratings, seller contact data, or posted timestamps because those require separately verified detail enrichment.

Results reflect the public inventory OfferUp returned at run time; deleted, sold, promoted, personalized, or region-limited listings can change later.

### Is it legal to scrape OfferUp?

This Actor extracts public marketplace search data without logging into an account.

You are responsible for ensuring your use complies with applicable laws, OfferUp terms, contractual obligations, privacy rules, and intellectual-property rights.

Do not use the data for spam, harassment, discrimination, prohibited profiling, or attempts to contact people unlawfully.

Collect only what your workflow needs and apply suitable retention and access controls.

### Troubleshooting

#### The run says no listings matched

Broaden the keyword or radius, remove strict condition/delivery filters, confirm the ZIP code, and try a small unfiltered run.

A strict filter intentionally excludes listings when OfferUp omits the field needed to verify it.

#### A request was blocked or throttled

The Actor retries and rotates residential sessions automatically. Review the log before raising `maxRequestRetries`; repeated retries increase time and proxy traffic.

#### A start URL is rejected

Only public `offerup.com/search` and `offerup.com/explore` URLs are accepted. Item, account, message, and external-domain URLs are outside this Actor’s scope.

#### Some optional fields are null

Null means the current OfferUp search feed did not publish that signal. The Actor does not fabricate values.

### Related marketplace scrapers

- [Craigslist Scraper](https://apify.com/automation-lab/craigslist-scraper) for US classifieds
- [Kijiji Scraper](https://apify.com/automation-lab/kijiji-scraper) for Canadian classifieds
- [eBay Scraper](https://apify.com/automation-lab/ebay-scraper) for auction and marketplace products
- [Wallapop Marketplace Scraper](https://apify.com/automation-lab/wallapop-marketplace-scraper) for Spanish second-hand listings

Use separate actors when you need source-specific fields and then merge records downstream using your own normalization rules.

### FAQ

#### Does it require an OfferUp account?

No. It reads anonymous public search data.

#### Can it scrape several cities?

Yes. Run multiple keyword/ZIP combinations as separate Actor runs or schedules so each market remains easy to monitor and price.

#### Does it scrape item descriptions or sellers?

Not in v1. Those detail fields are deliberately excluded until the detail route and its cost are independently verified.

#### Can I provide an OfferUp URL?

Yes, for public `/search` and `/explore` URLs. The Actor rejects unrelated paths and non-OfferUp hosts.

#### How do I avoid duplicates?

The Actor deduplicates exact listing IDs within each run. Store IDs between runs if your monitor also needs historical deduplication.

#### Why are condition-filtered results fewer?

OfferUp does not publish a condition on every search tile. The Actor fails closed rather than guessing that a missing value matches your requested condition.

### Support

If a valid public OfferUp search produces an unexpected failure, share the run URL, sanitized input, expected behavior, and the relevant log excerpt through the Actor issue form.

Do not include private account credentials, messages, or personal data.

# Actor input Schema

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

OfferUp searches to run, such as product names, brands, or vehicle models.

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

Optional offerup.com/search or offerup.com/explore URLs. URL targets are validated to stay on OfferUp.

## `zipCode` (type: `string`):

Five-digit ZIP code for local marketplace results.

## `radius` (type: `integer`):

Distance around the selected ZIP code.

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

Global maximum unique OfferUp listings to save across every keyword and URL.

## `categoryId` (type: `string`):

Optional OfferUp category identifier from an existing search URL.

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

Inclusive minimum listing price. Listings without a numeric price are excluded.

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

Inclusive maximum listing price. Listings without a numeric price are excluded.

## `conditions` (type: `array`):

Keep only listings whose condition can be verified as one of these values.

## `delivery` (type: `string`):

All listings, verified local pickup listings, or listings showing shipping availability.

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

OfferUp result ordering.

## `maxRequestRetries` (type: `integer`):

Maximum attempts per page when OfferUp blocks or throttles a residential session.

## Actor input object example

```json
{
  "keywords": [
    "iphone"
  ],
  "zipCode": "90001",
  "radius": 20,
  "maxItems": 10,
  "delivery": "all",
  "sortBy": "best_match",
  "maxRequestRetries": 3
}
```

# Actor output Schema

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

Unique OfferUp listings with prices, locations, delivery flags, images, IDs, and source metadata.

# 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 = {
    "keywords": [
        "iphone"
    ],
    "zipCode": "90001",
    "radius": 20,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/offerup-marketplace-listings-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 = {
    "keywords": ["iphone"],
    "zipCode": "90001",
    "radius": 20,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/offerup-marketplace-listings-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 '{
  "keywords": [
    "iphone"
  ],
  "zipCode": "90001",
  "radius": 20,
  "maxItems": 10
}' |
apify call automation-lab/offerup-marketplace-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OfferUp Marketplace Listings Scraper",
        "description": "Search public OfferUp US marketplace listings by keyword, ZIP, filters, or search URL. Export prices, locations, conditions, delivery flags, images, IDs, and listing URLs without login.",
        "version": "0.1",
        "x-build-id": "Hju3HsaWqr7446ykV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~offerup-marketplace-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-offerup-marketplace-listings-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/automation-lab~offerup-marketplace-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-offerup-marketplace-listings-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/automation-lab~offerup-marketplace-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-offerup-marketplace-listings-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": {
                    "keywords": {
                        "title": "🔎 Search keywords",
                        "type": "array",
                        "description": "OfferUp searches to run, such as product names, brands, or vehicle models.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "OfferUp search URLs",
                        "type": "array",
                        "description": "Optional offerup.com/search or offerup.com/explore URLs. URL targets are validated to stay on OfferUp.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "zipCode": {
                        "title": "📍 US ZIP code",
                        "pattern": "^[0-9]{5}$",
                        "type": "string",
                        "description": "Five-digit ZIP code for local marketplace results.",
                        "default": "90001"
                    },
                    "radius": {
                        "title": "Search radius (miles)",
                        "minimum": 5,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Distance around the selected ZIP code.",
                        "default": 30
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Global maximum unique OfferUp listings to save across every keyword and URL.",
                        "default": 20
                    },
                    "categoryId": {
                        "title": "🏷️ OfferUp category ID",
                        "type": "string",
                        "description": "Optional OfferUp category identifier from an existing search URL."
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Inclusive minimum listing price. Listings without a numeric price are excluded."
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Inclusive maximum listing price. Listings without a numeric price are excluded."
                    },
                    "conditions": {
                        "title": "Conditions",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only listings whose condition can be verified as one of these values.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "NEW",
                                "OPEN_BOX",
                                "REFURBISHED",
                                "USED",
                                "BROKEN"
                            ],
                            "enumTitles": [
                                "New",
                                "Open box",
                                "Reconditioned",
                                "Used",
                                "For parts"
                            ]
                        }
                    },
                    "delivery": {
                        "title": "Delivery method",
                        "enum": [
                            "all",
                            "local",
                            "shipping"
                        ],
                        "type": "string",
                        "description": "All listings, verified local pickup listings, or listings showing shipping availability.",
                        "default": "all"
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "best_match",
                            "recent",
                            "closest",
                            "price_low",
                            "price_high"
                        ],
                        "type": "string",
                        "description": "OfferUp result ordering.",
                        "default": "best_match"
                    },
                    "maxRequestRetries": {
                        "title": "🛡️ Request retries",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Maximum attempts per page when OfferUp blocks or throttles a residential session.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
