# OfferUp Scraper | Local Marketplace Listings (`parseforge/offerup-scraper`) Actor

Scrape OfferUp listings for electronics, furniture, cars, and more with title, price, condition, location, seller, photos, and description. Track local marketplace inventory and prices for resale arbitrage, market research, and competitive intelligence in second-hand commerce.

- **URL**: https://apify.com/parseforge/offerup-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$29.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🛒 OfferUp Scraper

> 🚀 **Export OfferUp marketplace listings in seconds.** No login required. No API key needed. Just search and download.

> 🕒 **Last updated:** 2026-05-22 · **📊 10 fields** per record · **Up to 1,000,000 items** · **US marketplace coverage**

The OfferUp Scraper extracts product listings from OfferUp's local buy-and-sell marketplace in real time using its GraphQL API. Each record includes the item title, price, condition, seller name, location, and a direct link to the listing - everything you need for competitive pricing, market research, or deal hunting.

OfferUp is one of the largest local commerce platforms in the United States, with tens of millions of listings across every product category imaginable - electronics, furniture, clothing, vehicles, and more. This scraper surfaces that inventory programmatically, page by page, with residential US proxies to ensure reliable access.

### Target Audience

| Who | Why |
|-----|-----|
| Resellers and flippers | Find underpriced items in bulk before competitors do |
| Market researchers | Track average asking prices by category or keyword |
| E-commerce sellers | Benchmark local competition for comparable items |
| Data scientists | Build price trend datasets across product categories |
| Bargain hunters | Automate deal discovery for specific keywords |

### 📋 What the OfferUp Scraper does

- Searches OfferUp listings by keyword in real time via GraphQL API
- Fetches full listing detail (seller, location, condition) for every result
- Paginates automatically until `maxItems` is reached or no more results exist
- Maps condition codes to human-readable labels (Fair, Good, Great, Like New, For Parts)
- Uses residential US proxies so results reflect real marketplace availability
- Outputs a clean, structured dataset ready for CSV, JSON, or Excel download

> 💡 **Why it matters:** OfferUp has no official public API. This actor is the only way to programmatically extract bulk listing data without manual browsing - saving hours of copy-paste work for anyone doing price research or inventory monitoring.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `keyword` | string | `laptop` | Search term to look up on OfferUp |
| `maxItems` | integer | `10` | Maximum number of listings to collect (free: 10, paid: up to 1,000,000) |

**Example 1 - Search for used bikes:**
```json
{
  "keyword": "mountain bike",
  "maxItems": 100
}
````

**Example 2 - Search for electronics, default limit:**

```json
{
  "keyword": "iphone 14"
}
```

> ⚠️ **Good to Know:** OfferUp results are US-only and reflect real-time local inventory. Results will vary by day. Free users are automatically limited to 10 items. Residential US proxies are required - the actor handles this automatically.

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 🖼️ `imageUrl` | string | Direct URL to the listing's main photo |
| 📝 `title` | string | Listing title as written by the seller |
| 💰 `price` | number | Asking price in USD |
| 🏷️ `condition` | string | Item condition (Fair, Good, Great, Like New, For Parts) |
| 📍 `location` | string | City or neighborhood where the item is listed |
| 👤 `sellerName` | string | Display name of the seller |
| 🆔 `sellerId` | string | Seller's internal OfferUp ID |
| 🔗 `listingUrl` | string | Direct link to the listing page |
| 🆔 `listingId` | string | OfferUp's internal listing ID |
| 🕒 `postedAt` | string | Date the listing was posted |
| 🕒 `scrapedAt` | string | ISO timestamp of when the record was collected |

**Sample record:**

```json
{
  "imageUrl": "https://img.offerupcdn.com/images/0109/1234567890/abc123.jpg",
  "title": "MacBook Pro 2021 14-inch M1 Pro 16GB 512GB",
  "price": 1200,
  "condition": "Like New",
  "location": "Austin, TX",
  "sellerName": "TechReseller",
  "sellerId": "83726541",
  "listingUrl": "https://offerup.com/item/detail/1234567890/",
  "listingId": "1234567890",
  "postedAt": "2026-05-20T14:32:00Z",
  "scrapedAt": "2026-05-22T09:15:00.000Z",
  "error": null
}
```

### ✨ Why choose this Actor

- **Residential US proxies built in** - no configuration needed, no blocks
- **GraphQL detail fetch** - goes deeper than the search results page to get seller info and high-res photos
- **Human-readable conditions** - numeric codes translated to plain English automatically
- **Pay-per-item pricing** - only pay for the records you actually collect
- **Free tier** - test with 10 real listings before committing

### 📈 How it compares to alternatives

| Feature | ParseForge OfferUp Scraper | Manual browsing | Generic scrapers |
|---------|---------------------------|-----------------|-----------------|
| Bulk export | Yes, up to 1M items | No | Partial |
| Residential proxies | Built in | N/A | Usually extra cost |
| Seller details | Yes | Yes | Rarely |
| Condition labels | Human-readable | Human-readable | Raw codes |
| Structured JSON/CSV | Yes | No | Sometimes |
| Free tier | 10 items | Unlimited (slow) | Rarely |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit)
2. Open the OfferUp Scraper actor page and click **Try for free**
3. Enter your search keyword (e.g. `gaming chair`, `road bike`, `iphone`)
4. Set `maxItems` to the number of listings you want
5. Click **Start** and wait for the run to finish (usually under 2 minutes for 100 items)
6. Download your dataset as CSV, JSON, Excel, or XML

### 💼 Business use cases

#### Resale and Arbitrage

Monitor OfferUp for underpriced electronics, sneakers, or furniture that can be resold at a profit on eBay or Amazon. Set up automated runs to catch new listings before competitors.

#### Competitive Pricing

Retailers and private sellers can track what similar items are selling for locally to price their own inventory competitively without guessing.

#### Inventory and Supply Research

Businesses sourcing second-hand goods (refurbishers, thrift stores, estate sale companies) can scan for bulk supply opportunities across specific categories.

#### Academic and Consumer Research

Economists and consumer behavior researchers can track local market pricing dynamics over time across cities and product categories.

### 🔌 Automating OfferUp Scraper

Connect the OfferUp Scraper to your favorite tools without code:

- **Make (formerly Integromat)** - Schedule daily runs and push new listings into a Google Sheet or Airtable database
- **Zapier** - Trigger an email or Slack notification whenever new listings matching your keyword appear
- **Slack** - Post deal alerts directly to a channel using the Apify Slack integration
- **Google Sheets** - Sync results automatically for team-wide visibility on pricing trends

### 🌟 Beyond business use cases

#### Personal Deal Hunting

Set up keyword alerts for items you've been searching for - vintage cameras, specific LEGO sets, rare records - and get notified when new listings appear.

#### Research and Journalism

Analyze local market dynamics for specific goods, or document pricing trends across cities for investigative reporting.

#### Hobbyist Community Tools

Build price guides for collector communities (trading cards, musical instruments, camera gear) using real transaction data from the largest US local marketplace.

#### Price History Tracking

Run daily snapshots to build a price history database for any product category and visualize how secondhand values change over time.

### 🤖 Ask an AI assistant about this scraper

Not sure how to structure your input or use the output? Ask an AI assistant:

> "I have JSON data from the OfferUp Scraper with fields like title, price, condition, and location. How do I filter for listings under $200 in Good or better condition and export them to a spreadsheet?"

The structured output from this actor is designed to work seamlessly with AI-powered data analysis tools.

### ❓ Frequently Asked Questions

**Does this scraper require an OfferUp account?**
No. All data is collected from publicly accessible listings. No login is required.

**Can I search by location?**
The scraper returns US listings. Location data is included in each record (the city/neighborhood the seller is in), but geographic filtering must be done on the output data.

**How many listings can I collect?**
Free users get 10 items per run. Paid users can collect up to 1,000,000 items per run.

**How current is the data?**
All data is scraped in real time at the moment you run the actor. There is no caching.

**What does the `condition` field contain?**
Conditions are mapped from OfferUp's internal scale: For Parts, Fair, Good, Great, Like New.

**What is `postedAt`?**
The date and time the seller originally posted the listing on OfferUp.

**Does it collect sold items?**
No. The scraper only collects active (unsold) listings.

**Can I filter by price range?**
Not at the input level - but you can filter the output dataset by the `price` field after export.

**What proxies are used?**
The actor automatically uses Apify residential US proxies, which are required for reliable OfferUp access.

**Is the data real-time?**
Yes. Every run fetches live data from OfferUp's GraphQL API. No cached responses are ever returned.

**Can I run this on a schedule?**
Yes. Use Apify's built-in scheduler to run daily or hourly scans for your target keywords.

**What if a listing has no price?**
The `price` field will be `null` for listings marked as "free" or with missing price data.

### 🔌 Integrate with any app

Export your dataset directly to:

**Spreadsheets:** Google Sheets, Microsoft Excel, Airtable

**Databases:** PostgreSQL, MySQL, MongoDB, Supabase

**Automation:** Make, Zapier, n8n, Pipedream

**Data tools:** Tableau, Power BI, Metabase, Google Looker Studio

**Developer APIs:** REST API, Python client, JavaScript client, CLI

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [Facebook Marketplace Scraper](https://apify.com/parseforge) | Extract local listings from Facebook Marketplace |
| [Craigslist Scraper](https://apify.com/parseforge) | Search Craigslist listings by keyword and city |
| [eBay Scraper](https://apify.com/parseforge) | Scrape active and sold eBay listings for pricing |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 50+ ready-to-use data extractors covering marketplaces, travel, real estate, jobs, and more.

***

**Disclaimer:** This actor is an independent tool not affiliated with, endorsed by, or connected to OfferUp Inc. It accesses only publicly available listing data. Use responsibly and in accordance with OfferUp's Terms of Service. ParseForge is not responsible for how collected data is used.

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword to search for (e.g. 'iphone', 'couch'). If provided, a keyword search is performed. Use either this or a Start URL, not both.

## `startUrl` (type: `string`):

OfferUp search or category URL (e.g. https://offerup.com/search?q=iphone). If provided, search filters below are ignored.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Fetch full details for each listing (seller info, description, shipping info, all photos). Slower but more complete.

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

Proxy settings. US residential proxies are required for OfferUp (geo-restricted to the US).

## `latitude` (type: `number`):

Latitude for location-based search (e.g. 40.7128 for New York City).

## `longitude` (type: `number`):

Longitude for location-based search (e.g. -74.006 for New York City).

## `distance` (type: `integer`):

Pickup radius in miles from the specified location (default: 50).

## `sortOrder` (type: `string`):

How to sort results.

## `deliveryType` (type: `string`):

Filter by pickup or shipping.

## `priceMin` (type: `integer`):

Minimum listing price in US dollars.

## `priceMax` (type: `integer`):

Maximum listing price in US dollars.

## `condition` (type: `array`):

Filter by item condition. Leave empty for all conditions. Options: NEW, OPEN\_BOX, REFURBISHED, USED, BROKEN, OTHER.

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

Maximum number of parallel detail requests. Lower this if you get rate-limited.

## Actor input object example

```json
{
  "searchQuery": "iphone",
  "maxItems": 10,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "distance": 50,
  "sortOrder": "-posted",
  "deliveryType": "p_s",
  "maxConcurrency": 5
}
```

# Actor output Schema

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

Dataset with all scraped items

# 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 = {
    "searchQuery": "iphone",
    "maxItems": 10,
    "includeDetails": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/offerup-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 = {
    "searchQuery": "iphone",
    "maxItems": 10,
    "includeDetails": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/offerup-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 '{
  "searchQuery": "iphone",
  "maxItems": 10,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call parseforge/offerup-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OfferUp Scraper | Local Marketplace Listings",
        "description": "Scrape OfferUp listings for electronics, furniture, cars, and more with title, price, condition, location, seller, photos, and description. Track local marketplace inventory and prices for resale arbitrage, market research, and competitive intelligence in second-hand commerce.",
        "version": "1.0",
        "x-build-id": "8cOxaSOGBaXoPtFlt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~offerup-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-offerup-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/parseforge~offerup-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-offerup-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/parseforge~offerup-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-offerup-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword to search for (e.g. 'iphone', 'couch'). If provided, a keyword search is performed. Use either this or a Start URL, not both."
                    },
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "OfferUp search or category URL (e.g. https://offerup.com/search?q=iphone). If provided, search filters below are ignored."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "includeDetails": {
                        "title": "Include Listing Details",
                        "type": "boolean",
                        "description": "Fetch full details for each listing (seller info, description, shipping info, all photos). Slower but more complete.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. US residential proxies are required for OfferUp (geo-restricted to the US)."
                    },
                    "latitude": {
                        "title": "Latitude",
                        "type": "number",
                        "description": "Latitude for location-based search (e.g. 40.7128 for New York City)."
                    },
                    "longitude": {
                        "title": "Longitude",
                        "type": "number",
                        "description": "Longitude for location-based search (e.g. -74.006 for New York City)."
                    },
                    "distance": {
                        "title": "Search Radius (miles)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Pickup radius in miles from the specified location (default: 50).",
                        "default": 50
                    },
                    "sortOrder": {
                        "title": "Sort Order",
                        "enum": [
                            "-posted",
                            "distance",
                            "price",
                            "-price"
                        ],
                        "type": "string",
                        "description": "How to sort results.",
                        "default": "-posted"
                    },
                    "deliveryType": {
                        "title": "Delivery Type",
                        "enum": [
                            "p_s",
                            "p",
                            "s"
                        ],
                        "type": "string",
                        "description": "Filter by pickup or shipping.",
                        "default": "p_s"
                    },
                    "priceMin": {
                        "title": "Minimum Price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum listing price in US dollars."
                    },
                    "priceMax": {
                        "title": "Maximum Price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum listing price in US dollars."
                    },
                    "condition": {
                        "title": "Item Condition",
                        "type": "array",
                        "description": "Filter by item condition. Leave empty for all conditions. Options: NEW, OPEN_BOX, REFURBISHED, USED, BROKEN, OTHER.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of parallel detail requests. Lower this if you get rate-limited.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```