# Facebook Marketplace Search (`dtrungtin/facebook-marketplace-search`) Actor

Extract listings from **[Facebook Marketplace](https://www.facebook.com/marketplace)** search results at scale.

- **URL**: https://apify.com/dtrungtin/facebook-marketplace-search.md
- **Developed by:** [Tin](https://apify.com/dtrungtin) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Facebook Marketplace Scraper

Extract listings from **[Facebook Marketplace](https://www.facebook.com/marketplace)** search results at scale. The scraper collects titles, prices, locations, photos, and listing URLs — without requiring a Facebook account (or optionally with one for more results). Run it on the Apify platform with built-in proxy rotation, scheduling, and export to JSON, CSV, or Excel.

### What does Facebook Marketplace Scraper do?

This Actor opens Facebook Marketplace search URLs, extracts the pre-rendered (SSR) listing data embedded in the page HTML, then scrolls to the bottom to load additional results via Facebook's GraphQL API. It deduplicates across both sources so every item appears exactly once.

Try it by pasting any Marketplace search URL — e.g. `https://www.facebook.com/marketplace/newyork/search/?query=iphone` — and setting a `maxItems` limit.

### Why use Facebook Marketplace Scraper?

- **Market research** — monitor prices for specific product categories across cities or countries
- **Resale & arbitrage** — automate deal-finding for goods sold below market value
- **Real estate leads** — track rental and property listings before they sell
- **Competitive intelligence** — watch how competitors list and price their inventory
- **Data science** — build price trend datasets for analysis or ML training

### How to use Facebook Marketplace Scraper

1. Go to [Facebook Marketplace](https://www.facebook.com/marketplace) and search for what you want to scrape.
2. Copy the search results URL from your browser's address bar.
3. Open the Actor's **Input** tab and paste the URL into **Start URLs**.
4. Set **Max items** to limit how many listings are collected (default: 10).
5. Optionally choose a **Proxy Country** to get results from a specific region.
6. Click **Start** and wait for the run to finish.
7. Download your results from the **Output** tab in JSON, CSV, or Excel.

### Input

Configure the Actor from the **Input** tab in Apify Console, or provide a JSON input:

| Field | Type | Description | Default |
|---|---|---|---|
| `startUrls` | array | Facebook Marketplace search URLs to scrape | *(required)* |
| `maxItems` | integer | Maximum number of listings to collect | `10` |
| `countryCode` | string | Proxy exit country (`US`, `DE`, `VN`, `FR`, `GB`) | `US` |
| `loginCookies` | array | Browser cookies for an authenticated Facebook session | — |

**Example input:**

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/marketplace/losangeles/search/?query=macbook" }
  ],
  "maxItems": 50,
  "countryCode": "US"
}
````

#### Using login cookies (optional)

To access more results or region-restricted listings, you can log in via cookies:

1. Install the [EditThisCookie v3](https://chromewebstore.google.com/detail/editthiscookie-v3/ojfebgpkimhlhcblbalbfjblapadhbol) Chrome extension.
2. Log in to Facebook in your browser.
3. Export your cookies using the extension and paste the JSON array into `loginCookies`.

> **Note:** When login cookies are used, the Actor runs with concurrency 1 to avoid triggering Facebook's account protection.

### Output

Results are saved to the default **Dataset**. Each item corresponds to one Marketplace listing.

**Example output (2 items):**

```json
[
  {
    "facebookUrl": "https://www.facebook.com/marketplace/losangeles/search/?query=macbook",
    "listingUrl": "https://www.facebook.com/marketplace/item/1234567890123456",
    "id": "1234567890123456",
    "name": "MacBook Pro 14\" M3 - Like New",
    "listing_price": {
      "amount": "1200",
      "currency": "USD",
      "formatted_amount": "$1,200"
    },
    "location": {
      "reverse_geocode": {
        "city": "Los Angeles",
        "state": "California"
      }
    },
    "primary_listing_photo": {
      "image": {
        "uri": "https://scontent.xx.fbcdn.net/v/..."
      }
    }
  },
  {
    "facebookUrl": "https://www.facebook.com/marketplace/losangeles/search/?query=macbook",
    "listingUrl": "https://www.facebook.com/marketplace/item/9876543210987654",
    "id": "9876543210987654",
    "name": "MacBook Air M2 Space Gray 256GB",
    "listing_price": {
      "amount": "750",
      "currency": "USD",
      "formatted_amount": "$750"
    },
    "location": {
      "reverse_geocode": {
        "city": "Santa Monica",
        "state": "California"
      }
    },
    "primary_listing_photo": {
      "image": {
        "uri": "https://scontent.xx.fbcdn.net/v/..."
      }
    }
  }
]
```

You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel**.

### Data fields

| Field | Description |
|---|---|
| `facebookUrl` | The Marketplace search URL that was scraped |
| `listingUrl` | Direct link to the individual listing page |
| `id` | Facebook's unique listing ID |
| `name` | Listing title |
| `listing_price.amount` | Price as a numeric string |
| `listing_price.currency` | Currency code (e.g. `USD`) |
| `listing_price.formatted_amount` | Human-readable price (e.g. `$1,200`) |
| `location.reverse_geocode.city` | City where the listing is located |
| `location.reverse_geocode.state` | State/region of the listing |
| `primary_listing_photo.image.uri` | URL of the listing's main photo |

### Pricing / Cost estimation

This Actor uses **Puppeteer (headless Chrome)** and **residential proxies**, which are more expensive than HTTP-only scrapers. Typical costs on Apify:

- **~0.10–0.20 compute units** per run for 50–100 listings
- Residential proxy bandwidth adds cost depending on page size (~1–3 MB per search page)

The **Apify Free plan** includes $5/month in free usage, enough for hundreds of listings. For large-scale or recurring scrapes, a paid plan is recommended.

### Tips and advanced options

- **Scrape multiple cities** — add several search URLs in `startUrls`, each targeting a different location (e.g. `/marketplace/chicago/`, `/marketplace/houston/`).
- **Filter by category** — Facebook Marketplace URLs support category filters. Apply them in the browser first, then copy the filtered URL.
- **Set `maxItems` conservatively** — for price monitoring use cases, 20–50 items per run keeps costs low. The scraper scrolls until the limit is reached, avoiding unnecessary network requests.
- **Schedule recurring runs** — use Apify's built-in scheduler to run the Actor daily or hourly and detect new listings automatically.
- **Export to Google Sheets** — use the [Apify Google Sheets integration](https://apify.com/integrations) to push results directly to a spreadsheet.

### FAQ, disclaimers, and support

**Is it legal to scrape Facebook Marketplace?**
Web scraping publicly visible data is generally permitted for personal, research, and non-commercial purposes in many jurisdictions. However, Facebook's Terms of Service prohibit automated data collection. Use this Actor responsibly, respect rate limits, and do not store personal data without a legal basis. Always consult a legal professional for your specific use case.

**Will it work without a Facebook account?**
Yes — the Actor scrapes publicly visible search results. Login cookies are optional and may increase the number of results visible.

**Why are fewer results returned than `maxItems`?**
Facebook may limit results for unauthenticated sessions, or the search query may have fewer matching listings than the limit.

**Known limitations**

- Facebook frequently changes its internal data structures; the scraper may need updates if extraction breaks.
- Very high concurrency is not recommended — use the default single-session mode to avoid account flags.

**Support**
Found a bug or need a custom solution? Open an issue on the [Issues tab](../../issues) or contact us through [Apify Console](https://console.apify.com).

### Included features

- **[Puppeteer Crawler](https://crawlee.dev/api/puppeteer-crawler/class/PuppeteerCrawler)** - simple framework for parallel crawling of web pages using headless Chrome with Puppeteer
- **[Configurable Proxy](https://crawlee.dev/docs/guides/proxy-management#proxy-configuration)** - tool for working around IP blocking
- **[Input schema](https://docs.apify.com/platform/actors/development/input-schema)** - define and easily validate a schema for your Actor's input
- **[Dataset](https://docs.apify.com/sdk/js/docs/guides/result-storage#dataset)** - store structured data where each object stored has the same attributes
- **[Apify SDK](https://docs.apify.com/api/client/js/)** - toolkit for building Actors

### How it works

1. `Actor.getInput()` gets the input from `INPUT.json` where the start urls are defined

2. Create a configuration for proxy servers to be used during the crawling with `Actor.createProxyConfiguration()` to work around IP blocking. Use Apify Proxy or your own Proxy URLs provided and rotated according to the configuration. You can read more about proxy configuration [here](https://crawlee.dev/api/core/class/ProxyConfiguration).

3. Create an instance of Crawlee's Puppeteer Crawler with `new PuppeteerCrawler()`. You can pass [options](https://crawlee.dev/api/puppeteer-crawler/interface/PuppeteerCrawlerOptions) to the crawler constructor as:
   - `proxyConfiguration` - provide the proxy configuration to the crawler
   - `requestHandler` - handle each request with custom router defined in the `routes.js` file.

4. Handle requests with the custom router from `routes.js` file. Read more about custom routing for the Cheerio Crawler [here](https://crawlee.dev/api/puppeteer-crawler/function/createPuppeteerRouter)
   - Create a new router instance with `new createPuppeteerRouter()`
   - Define default handler that will be called for all URLs that are not handled by other handlers by adding `router.addDefaultHandler(() => { ... })`
   - Define additional handlers - here you can add your own handling of the page

     ```javascript
     router.addHandler('detail', async ({ request, page, log }) => {
         const title = await page.title();
         // You can add your own page handling here

         await Dataset.pushData({
             url: request.loadedUrl,
             title,
         });
     });
     ```

5. `crawler.run(startUrls);` start the crawler and wait for its finish

### Resources

If you're looking for examples or want to learn more visit:

- [Crawlee + Apify Platform guide](https://crawlee.dev/docs/guides/apify-platform)
- [Documentation](https://crawlee.dev/api/playwright-crawler/class/PlaywrightCrawler) and [examples](https://crawlee.dev/docs/examples/playwright-crawler)
- [Node.js tutorials](https://docs.apify.com/academy/node-js) in Academy
- [How to scale Puppeteer and Playwright](https://blog.apify.com/how-to-scale-puppeteer-and-playwright/)
- [Video guide on getting data using Apify API](https://www.youtube.com/watch?v=ViYYDHSBAKM)
- [Integration with Make](https://apify.com/integrations), GitHub, Zapier, Google Drive, and other apps
- A short guide on how to create Actors using code templates:

[web scraper template](https://www.youtube.com/watch?v=u-i-Korzf8w)

### Getting started

For complete information [see this article](https://docs.apify.com/platform/actors/development#build-actor-locally). To run the Actor use the following command:

```bash
apify run
```

### Deploy to Apify

#### Connect Git repository to Apify

If you've created a Git repository for the project, you can easily connect to Apify:

1. Go to [Actor creation page](https://console.apify.com/actors/new)
2. Click on **Link Git Repository** button

#### Push project on your local machine to Apify

You can also deploy the project on your local machine to Apify without the need for the Git repository.

1. Log in to Apify. You will need to provide your [Apify API Token](https://console.apify.com/account/integrations) to complete this action.

   ```bash
   apify login
   ```

2. Deploy your Actor. This command will deploy and build the Actor on the Apify Platform. You can find your newly created Actor under [Actors -> My Actors](https://console.apify.com/actors?tab=my).

   ```bash
   apify push
   ```

### Documentation reference

To learn more about Apify and Actors, take a look at the following resources:

- [Apify SDK for JavaScript documentation](https://docs.apify.com/sdk/js)
- [Apify SDK for Python documentation](https://docs.apify.com/sdk/python)
- [Apify Platform documentation](https://docs.apify.com/platform)
- [Join our developer community on Discord](https://discord.com/invite/jyEM2PRvMU)

# Actor input Schema

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

URLs to start with.

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

Limit of items to be scraped

## `countryCode` (type: `string`):

Country for the residential proxy exit node. Use this when the target site serves different content by region.

## `loginCookies` (type: `array`):

If you want to sign in to the web page so that you will have access to more data than with an anonymous profile, but do not wish to save your credentials in input, then you can use your cookies.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/marketplace/saltlakecity/search/?query=xiaomi"
    }
  ],
  "maxItems": 10,
  "countryCode": "US"
}
```

# 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.facebook.com/marketplace/saltlakecity/search/?query=xiaomi"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("dtrungtin/facebook-marketplace-search").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.facebook.com/marketplace/saltlakecity/search/?query=xiaomi" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("dtrungtin/facebook-marketplace-search").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.facebook.com/marketplace/saltlakecity/search/?query=xiaomi"
    }
  ],
  "maxItems": 10
}' |
apify call dtrungtin/facebook-marketplace-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Marketplace Search",
        "description": "Extract listings from **[Facebook Marketplace](https://www.facebook.com/marketplace)** search results at scale.",
        "version": "0.0",
        "x-build-id": "yAkUem0F6NoLzClO1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dtrungtin~facebook-marketplace-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dtrungtin-facebook-marketplace-search",
                "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/dtrungtin~facebook-marketplace-search/runs": {
            "post": {
                "operationId": "runs-sync-dtrungtin-facebook-marketplace-search",
                "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/dtrungtin~facebook-marketplace-search/run-sync": {
            "post": {
                "operationId": "run-sync-dtrungtin-facebook-marketplace-search",
                "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": "Start URLs",
                        "type": "array",
                        "description": "URLs to start with.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "type": "integer",
                        "description": "Limit of items to be scraped",
                        "default": 10
                    },
                    "countryCode": {
                        "title": "Proxy Country",
                        "enum": [
                            "US",
                            "DE",
                            "VN",
                            "FR",
                            "GB"
                        ],
                        "type": "string",
                        "description": "Country for the residential proxy exit node. Use this when the target site serves different content by region.",
                        "default": "US"
                    },
                    "loginCookies": {
                        "title": "Cookies",
                        "type": "array",
                        "description": "If you want to sign in to the web page so that you will have access to more data than with an anonymous profile, but do not wish to save your credentials in input, then you can use your cookies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
