# Facebook Marketplace Product Scraper (`sovanza.inc/facebook-marketplace-product-scraper`) Actor

Scrape Facebook Marketplace listing data (price, title, seller, images, location) using URLs and export it as structured data for analysis and automation.

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

## Pricing

$15.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

### Facebook Marketplace Product Scraper

### What is Facebook Marketplace Product Scraper and How Does It Work?

Facebook Marketplace Product Scraper is a powerful Facebook Marketplace data extraction tool built on Apify that lets you scrape product listings from Facebook Marketplace using listing URLs. It is designed for eCommerce teams, marketers, researchers, and lead-generation workflows who want to automate listing research, competitor checks, and catalog-style data collection — without relying on Facebook’s official Marketplace API.

### Why Use This Facebook Marketplace Scraper?

Use this scraper to:

- Extract listing data from Facebook Marketplace at scale
- Monitor competitor or category listings when you have valid listing URLs
- Collect seller- and location-related fields where Facebook exposes them
- Build structured datasets for analytics, CRM, or downstream automation
- Automate what would otherwise be manual browsing of Marketplace listings

### Features

- Scrape **Facebook Marketplace listing URLs** (`/marketplace/item/...` or `/marketplace/<id>/`)
- Support **multiple listing URLs** in one run via `productUrls`
- Extract listing-level data aligned with common Marketplace fields (title, price, images, seller, location, delivery, status flags)
- Optional **session cookies** input when listings require login
- **Proxy country** selection for Apify Proxy
- Structured output in JSON (and CSV/Excel via Apify dataset export)

### How to Use Facebook Marketplace Product Scraper on Apify

#### Using the Actor

To use this scraper on Apify, follow these simple steps:

1. **Go to the Facebook Marketplace Product Scraper** on the Apify platform.

2. **Input Configuration**:
   - Enter one or more Facebook Marketplace **listing** URLs.
   - Optionally set proxy country and session cookies if listings require authentication or are unstable from datacenter IPs.

#### Input Configuration

The actor accepts the following input parameters:

```json
{
  "productUrls": [
    "https://www.facebook.com/marketplace/item/1189200412268517"
  ],
  "maxListings": 100,
  "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY",
  "cookies": []
}
````

- `productUrls` (required): One or more Facebook Marketplace listing URLs (`/marketplace/item/...` or `/marketplace/<id>/`). Use the string list editor in the Console or a JSON array.
- `maxListings` (optional): Maximum listings per feed-style URL when applicable (default `100`, min `1`, max `1000`). For single listing URLs, behavior is documented in the actor; see [Supported URLs](#supported-urls) below.
- `proxyCountry` (optional): Country for proxy — `AUTO_SELECT_PROXY_COUNTRY`, `US`, `GB`, `DE`, `FR`, `JP`, `CA`, `IT` (default: `AUTO_SELECT_PROXY_COUNTRY`).
- `cookies` (optional): Facebook session cookies for authenticated access when listings show login walls. Array of `{ "name", "value", "domain" (optional), "path" (optional) }`. For HttpOnly session cookies like **`xs`**, export from DevTools → Application → Cookies for `https://www.facebook.com` and add `{ "name": "xs", "value": "<value>", "domain": ".facebook.com", "path": "/" }` to the array.

3. **Run the Actor**:
   - Click **Start** to begin scraping.
   - The actor processes each URL and writes results to the default dataset.

4. **Access Your Results**:
   - Open the **Dataset** tab.
   - Export as JSON, CSV, or Excel, or use the Apify API.

5. **Schedule Regular Runs** (Optional):
   - Schedule recurring runs to refresh listing snapshots.
   - Use webhooks to trigger downstream workflows when runs complete.

### Supported URLs

- **Listing URLs:** `https://www.facebook.com/marketplace/item/<id>` or `https://www.facebook.com/marketplace/<id>/`

This actor is oriented toward **listing (product) URLs**. See the actor’s source description for any feed/search URL limits.

### Output

All results are stored in Apify dataset storage. Each item in the dataset typically includes fields such as:

- `facebookUrl` — Source Facebook URL used for the scrape
- `listingUrl` — Listing page URL
- `id` — Listing ID
- `marketplace_listing_title` — Listing title
- `listing_price` — Price object (e.g. `formatted_amount`, `amount`)
- `primary_listing_photo` — Primary photo object (e.g. `image.uri`)
- `location` — Location object (e.g. city/state via `reverse_geocode`)
- `marketplace_listing_seller` — Seller object (`name`, `id`, etc.)
- `is_live`, `is_sold` — Listing status flags
- `delivery_types` — e.g. `["IN_PERSON"]`

**Flat compatibility fields** for tooling and exports:

- `url`, `title`, `price`, `description`, `images`, `seller`, `location`, `condition`, `shipping`, `timestamp`

**On error:** items may include `url` and `error` instead of full listing data.

Example successful item (simplified):

```json
{
  "url": "https://www.facebook.com/marketplace/item/1189200412268517",
  "title": "Example item",
  "price": "$50",
  "listing_price": { "formatted_amount": "$50", "amount": "5000" },
  "marketplace_listing_title": "Example item",
  "marketplace_listing_seller": { "name": "Seller Name", "id": "123" },
  "location": { "reverse_geocode": { "city": "Dubai", "state": null } },
  "images": ["https://..."],
  "error": null
}
```

Example error item:

```json
{
  "url": "https://www.facebook.com/marketplace/item/invalid",
  "error": "Product not found or no longer available"
}
```

### How the Scraper Works

- **Playwright** loads Marketplace listing pages in a headless browser.
- **Extraction** in `extract_product_data()` (`main.py`):
  - Title: `<h1>`, `[data-testid="marketplace_pdp_title"]`, or `og:title`
  - Price: embedded JSON or DOM, `[data-testid="marketplace_pdp_price"]`
  - Description: embedded JSON or `[data-testid="marketplace_pdp_description"]`
  - Images: embedded photos or `og:image` / CDN URLs
  - Seller, location, condition, shipping: labeled sections or embedded JSON

### Anti-blocking Measures

- Uses Apify Proxy with configurable **proxy country**.
- Optional **session cookies** for logged-in scraping when Facebook shows login walls.
- Retries and error handling for network failures (see `MAX_RETRIES` in code).

### Performance Optimization

- Batch multiple `productUrls` in one run.
- Use cookies only when needed to reduce operational overhead.

### Why Choose This Actor?

- High-demand Marketplace data in a structured dataset
- Lead-generation and listing research workflows
- Scalable multi-URL runs on Apify
- Clean structured output aligned with common Marketplace field shapes
- Automation-ready via API, schedules, and webhooks

### Integrations & API

- Use as API via Apify
- Integrate with Python & Node.js
- Connect with Zapier, Make, Google Sheets
- Automate workflows with webhooks
- Schedule recurring scraping

### FAQ

#### How does Facebook Marketplace Scraper work?

It opens publicly reachable listing pages (and optionally authenticated sessions via cookies), extracts structured listing data from the DOM and embedded JSON, and writes rows to the Apify dataset.

#### Can I scrape listings from specific locations?

Location appears in output when Facebook exposes it on the listing. **Targeting by city** is typically done by using listing URLs that already reflect that context, or by your own URL discovery workflow.

#### Can I extract seller information?

Yes, when available — see `marketplace_listing_seller` and flat `seller` fields.

#### Can I scrape multiple listings at once?

Yes. Pass multiple URLs in `productUrls`.

#### Does it require the Facebook Marketplace API?

No. It does not use Facebook’s official API for this flow.

#### Is the data accurate?

Data reflects what is shown on the listing page at scrape time. Facebook may change markup.

#### Can I automate scraping?

Yes — Apify API, scheduling, and integrations.

#### What formats are supported?

JSON, CSV, Excel via Apify dataset export, plus API access.

#### Can I use this for lead generation?

Yes — subject to Facebook’s terms and applicable laws.

#### Can I connect this scraper to Google Sheets?

Yes — via export or integrations (e.g. Make, Zapier).

#### Can I use this for AI or machine learning projects?

Yes — structured fields are suitable for analytics pipelines.

#### Is scraping Facebook Marketplace legal?

Scraping publicly available data may be allowed in some jurisdictions, but you must follow **Facebook’s Terms of Service**, robots rules where applicable, and **local laws**. Use responsibly.

### SEO Keywords

facebook marketplace scraper\
facebook marketplace data scraper\
facebook marketplace product scraper\
facebook marketplace listings scraper\
facebook marketplace scraping api\
facebook marketplace lead generation\
scrape facebook marketplace data\
facebook marketplace automation tool\
facebook marketplace product research\
best facebook marketplace scraper\
facebook marketplace scraper apify

### Actor permissions

This Actor is designed to work with **limited permissions**. It only reads input and writes to its default dataset; it does not access other user data or require full account access.

**To set limited permissions in Apify Console:**

1. Open your Actor on the Apify platform.
2. Go to the **Source** tab (or **Settings**).
3. Click **Review permissions** (or open **Settings** → **Permissions**).
4. Select **Limited permissions** and save.

### Limitations

- Facebook may block or throttle datacenter IPs; **proxies and/or cookies** may be required.
- Listing markup changes can break selectors until the actor is updated.
- **Login-required** or restricted listings need valid session cookies.
- Invalid URLs or non-listing URLs may be skipped or return errors.

### Error handling

- **Invalid URL**: not a supported listing URL — skipped or error row.
- **Not found / unavailable**: `{ url, error: "Product not found or no longer available" }`.
- **Login required**: `{ url, error: "Login required... Add Facebook session cookies..." }` — add `cookies`.
- **Network / timeout**: Retries, then `{ url, error: message }`.

### API route (for backend integration)

Example: `POST /api/scraper/facebook-marketplace` with body `{ "url": "https://www.facebook.com/marketplace/item/xxxxx" }`.\
Response: `{ success: true, data: { ... } }` or `{ success: false, error: "..." }`.\
See `routes/facebook_marketplace.example.js` in the repo.

### Run locally

```bash
pip install -r requirements.txt
playwright install chromium
## Edit INPUT.json with Marketplace listing URLs
python main.py
```

### Docker

Use the provided Dockerfile to build and run the actor, consistent with other Apify actors in this monorepo.

### License

See the repository root or this package’s `LICENSE` file for license terms, if present.

### Get Started

Start extracting Facebook Marketplace data and generate valuable insights and leads today. 🚀

# Actor input Schema

## `productUrls` (type: `array`):

Enter one or more Facebook Marketplace URLs: single listing (marketplace/item/xxx or marketplace/123/) or feed (city/search, city/category). One per line.

## `maxListings` (type: `integer`):

Maximum listing cards to collect per feed URL (1–1000). Lower defaults keep Store sample runs fast.

## `maxDetailPages` (type: `integer`):

After collecting the feed, open at most this many listing pages for full PDP extraction. Remaining rows use feed-only data. Use 0 to skip PDP visits.

## `enrichProductPages` (type: `boolean`):

If true, opens individual listing pages for richer fields (slower). If false, returns feed card data only (faster).

## `proxyCountry` (type: `string`):

Residential proxy country (uses Apify Proxy). AUTO uses any country.

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

Facebook session cookies for authenticated access. Use when listings require login. Each item: { "name": "c\_user", "value": "...", "domain": ".facebook.com", "path": "/" }.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.facebook.com/marketplace/sanfrancisco/search/?query=guitar"
  ],
  "maxListings": 12,
  "maxDetailPages": 15,
  "enrichProductPages": true,
  "proxyCountry": "AUTO_SELECT_PROXY_COUNTRY"
}
```

# 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 = {
    "productUrls": [
        "https://www.facebook.com/marketplace/sanfrancisco/search/?query=guitar"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sovanza.inc/facebook-marketplace-product-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 = { "productUrls": ["https://www.facebook.com/marketplace/sanfrancisco/search/?query=guitar"] }

# Run the Actor and wait for it to finish
run = client.actor("sovanza.inc/facebook-marketplace-product-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 '{
  "productUrls": [
    "https://www.facebook.com/marketplace/sanfrancisco/search/?query=guitar"
  ]
}' |
apify call sovanza.inc/facebook-marketplace-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Marketplace Product Scraper",
        "description": "Scrape Facebook Marketplace listing data (price, title, seller, images, location) using URLs and export it as structured data for analysis and automation.",
        "version": "0.0",
        "x-build-id": "402cJEtlMlhIso59S"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sovanza.inc~facebook-marketplace-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sovanza.inc-facebook-marketplace-product-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/sovanza.inc~facebook-marketplace-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sovanza.inc-facebook-marketplace-product-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/sovanza.inc~facebook-marketplace-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sovanza.inc-facebook-marketplace-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "Single/Multiple Product URL's",
                        "type": "array",
                        "description": "Enter one or more Facebook Marketplace URLs: single listing (marketplace/item/xxx or marketplace/123/) or feed (city/search, city/category). One per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxListings": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum listing cards to collect per feed URL (1–1000). Lower defaults keep Store sample runs fast.",
                        "default": 12
                    },
                    "maxDetailPages": {
                        "title": "Max detail pages (feed URLs)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "After collecting the feed, open at most this many listing pages for full PDP extraction. Remaining rows use feed-only data. Use 0 to skip PDP visits.",
                        "default": 15
                    },
                    "enrichProductPages": {
                        "title": "Enrich with listing detail pages",
                        "type": "boolean",
                        "description": "If true, opens individual listing pages for richer fields (slower). If false, returns feed card data only (faster).",
                        "default": true
                    },
                    "proxyCountry": {
                        "title": "Proxy Country",
                        "enum": [
                            "AUTO_SELECT_PROXY_COUNTRY",
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "JP",
                            "CA",
                            "IT"
                        ],
                        "type": "string",
                        "description": "Residential proxy country (uses Apify Proxy). AUTO uses any country.",
                        "default": "AUTO_SELECT_PROXY_COUNTRY"
                    },
                    "cookies": {
                        "title": "Session cookies (optional)",
                        "type": "array",
                        "description": "Facebook session cookies for authenticated access. Use when listings require login. Each item: { \"name\": \"c_user\", \"value\": \"...\", \"domain\": \".facebook.com\", \"path\": \"/\" }."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
