# Lespac Product Search Scraper (`stealth_mode/lespac-product-search-scraper`) Actor

Scrape product listings from Lespac.com search results with precision. Collect titles, prices, descriptions, images, locations, and 20+ metadata fields per item — perfect for price monitoring, market analysis, and classified ad aggregation.

- **URL**: https://apify.com/stealth\_mode/lespac-product-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are 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

## Lespac Product Search Scraper: Extract Classified Listings at Scale

---

### What Is Lespac.com?

Lespac.com is one of Canada's largest online classified platforms, hosting millions of listings across categories like vehicles, real estate, electronics, and general merchandise. With new products posted daily and prices fluctuating constantly, manually tracking listings is inefficient. The **Lespac Product Search Scraper** automates collection of search results, converting raw listing pages into structured, queryable datasets.

---

### Overview

The **Lespac Product Search Scraper** extracts individual product listings from Lespac search results pages. It captures 20+ fields per item, including pricing, images, descriptions, and location data. Ideal for:

- **Price monitors** tracking competitor pricing across categories
- **Market researchers** analyzing product availability and pricing trends
- **Aggregators** building classified ad feeds or comparison tools
- **Business intelligence** teams conducting market analysis
- **Real estate analysts** monitoring property listings by region

The scraper handles bulk operations efficiently, supporting up to hundreds of items per URL and graceful failure handling.

---

### Input Format

The scraper accepts a JSON configuration:

```json
{
  "urls": [
    "https://www.lespac.com/montreal/vehicules-autos_b286g17567k1R2.jsa?ncc=dx0i1irZ006dHJ1ZQis20j0"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

| Field | Description |
|---|---|
| `urls` | Array of Lespac search result page URLs. Copy directly from your browser after filtering by category, location, or price range. |
| `max_items_per_url` | Maximum items to extract per URL (e.g., `200`). Useful for controlling dataset size or pagination. |
| `ignore_url_failures` | If `true`, the scraper continues even if individual URLs fail. Set to `false` if you want strict validation. |

**Example URLs:**

- Vehicle listings: `https://www.lespac.com/montreal/vehicules-autos_b286g17567k1R2.jsa`
- Electronics: `https://www.lespac.com/toronto/informatique-electronique_b32g17567k1R2.jsa`

> **Tip:** You can apply filters directly in Lespac (location, price range, keyword) and paste the filtered URL to scrape specific subsets.

***

### Output Format

**Sample output**

```json
{
  "listing_public_id": "223181043",
  "category_code": "VEHICULES_AUTOS",
  "title": "DODGE R/T 2020 SHOW ROOM",
  "description": "Dodge Charger R/T en excellente condition avec seulement 53000KM, tout équipé, Uconnect Roues, Pneus et freins neuf, vitres teintées, roule comme un neuf, confortable et puissant.Dodge Charger R/T in excellent condition with only 53,000 KM, fully equipped, Uconnect, wheels, tires and brakes new, tinted windows, drives like new, comfortable and",
  "public_release_timestamp": 1781263739000,
  "published_since_label": "Parue depuis 17 heures",
  "published_since_short_label": "17 heures",
  "price": 32500.0,
  "price_note": "Négociable",
  "price_label": "32 500 $",
  "price_note_type": "COMPLEMENTARY",
  "priority_placement_layout_flag": "BASIC",
  "characteristics": [
    {
      "icon_url": "https://cdn.lespac.com/images/listing-characteristics/ic_kilometrage.png",
      "label": "Kilométrage",
      "short_label": "Kilométrage",
      "value": "53 000 km"
    },
    {
      "icon_url": "https://cdn.lespac.com/images/listing-characteristics/ic_motricite.png",
      "label": "Motricité",
      "short_label": "Motricité",
      "value": "Roues motrices arrière"
    }
  ],
  "images": [
    {
      "format_placeholder": "%FORMAT%",
      "formattable_image_url": "https://cdn.lespac.com/binary/%FORMAT%/3170148470.jpg"
    },
    {
      "format_placeholder": "%FORMAT%",
      "formattable_image_url": "https://cdn.lespac.com/binary/%FORMAT%/3170148471.jpg"
    },
    {
      "format_placeholder": "%FORMAT%",
      "formattable_image_url": "https://cdn.lespac.com/binary/%FORMAT%/3170148472.jpg"
    },
    {
      "format_placeholder": "%FORMAT%",
      "formattable_image_url": "https://cdn.lespac.com/binary/%FORMAT%/3170148473.jpg"
    },
    {
      "format_placeholder": "%FORMAT%",
      "formattable_image_url": "https://cdn.lespac.com/binary/%FORMAT%/3170148474.jpg"
    }
  ],
  "main_image_url": "https://cdn.lespac.com/binary/zoomedGallery/3170148470.jpg",
  "listing_display_url": "https://www.lespac.com/gatineau/vehicules-autos/dodge-r-t-2020-show-room_223181043D0.jsa?searchCriteria=L21vbnRyZWFsL3ZlaGljdWxlcy1hdXRvc19iMjg2ZzE3NTY3azJSMi5qc2E_bmNjPWR4MGkxaXJaMDA2ZEhKMVpRaXMyMGow&navigationInfo=YT0yMCZiPTEmYz0yMjMxODEwNDNTMjE4ODc3NjcyUzIyMzIxNDE4M1MyMjMyMTIxMzhTMjIzMjEyMDAzUzIyMzE5NDQyOFMyMjMyMDEwMjNTMjIzMjAwOTk5UzIyMzE5MjE4NFMyMjE0MDgwNDJTMjIyODgxNDMwUzIyMjg4NjQwMVMyMjI4ODE0MzJTMjIxNDcyMDI4UzIyMzE3ODI2OFMyMjMxNzgyNjVTMjIzMTc4MjYzUzIyMzE3ODA5MlMyMjMxNzgwNTFTMjIzMTA5NDQzJmQ9MA&requester=SCHP",
  "distance_label": "163 km",
  "city_label": "Gatineau",
  "search_page_tracking_info": {
    "listing-regionid": {
      "value": "17569"
    },
    "listing-region": {
      "value": "REGION_OUTAOUAIS"
    },
    "listing-categoryid": {
      "value": "286"
    },
    "listing-condition": {
      "value": "USED"
    },
    "listing-price": {
      "value": "32500.0"
    },
    "listing-category": {
      "value": "Vehicles - Cars"
    },
    "listing-category-code": {
      "value": "VEHICULES_AUTOS"
    },
    "listing-upgrade-pinned-ad": {
      "value": "yes"
    },
    "listing-upgrade-home-page": {
      "value": "yes"
    },
    "listing-dealerid": {
      "value": "5414230"
    },
    "listing-operation-type": {
      "value": "OFFER"
    },
    "listing-upgrade-bump-up": {
      "value": "no"
    },
    "listing-id": {
      "value": "223181043"
    },
    "listing-advertiser-type": {
      "value": "INDIVIDUAL"
    },
    "listing-upgrade-tag": {
      "value": "no"
    },
    "listing-year": {
      "value": "2020"
    },
    "listing-upgrade-feature-listing": {
      "value": "no"
    },
    "listing-merchantid": {
      "value": "Serge Gauthier"
    },
    "listing-region-code": {
      "value": "Outaouais"
    },
    "listing-pos": {
      "value": "5"
    },
    "listing-list": {
      "value": "search results - pinned ads"
    }
  },
  "search_logger_listing_id": 25256929794,
  "search_logger_priority_placement_id": 25251625759,
  "from_url": "https://www.lespac.com/montreal/vehicules-autos_b286g17567k2R2.jsa?ncc=dx0i1irZ006dHJ1ZQis20j0"
}
```

Each scraped listing returns a record with 20 fields containing identification, pricing, content, media, and location data:

#### Listing Identification

| Field | Meaning | Example |
|---|---|---|
| `Listing Public ID` | Unique identifier for the product listing | `abc123xyz789` |
| `Category Code` | Classification code for the product type | `b286g17567k1R2` (vehicles category) |
| `Search Logger Listing ID` | Tracking ID used internally for analytics | Used to correlate with click/view events |
| `Search Logger Priority Placement ID` | ID for premium/promoted listings | Null if listing is organic |

#### Product Information

| Field | Meaning | Example |
|---|---|---|
| `Title` | Product name as displayed in search results | `2015 Honda Civic - Great Condition` |
| `Description` | Full product description with details | `Low mileage, one owner, well maintained...` |
| `Characteristics` | Structured product attributes (JSON or key-value pairs) | `{"Year": 2015, "Color": "Silver", "Transmission": "Automatic"}` |
| `Main Image URL` | Direct link to the primary product photo | `https://images.lespac.com/photo123.jpg` |
| `Images` | Array of all product image URLs | `[url1, url2, url3, ...]` |

#### Pricing

| Field | Meaning | Example |
|---|---|---|
| `Price` | Listed price in CAD or local currency | `$12,500` |
| `Price Label` | Formatted price string for display | `$12,500 OBO` |
| `Price Note` | Additional pricing information | `Negotiable, Price negotiable` |
| `Price Note Type` | Classification of price note | `NEGOTIABLE`, `FIRM`, `CONTACT` |

#### Timestamp & Availability

| Field | Meaning | Example |
|---|---|---|
| `Public Release Timestamp` | Unix timestamp when listing was published | `1690512000` |
| `Published Since Label` | Human-readable time ago (long format) | `Posted 3 days ago` |
| `Published Since Short Label` | Human-readable time ago (short format) | `3d` |

#### Location & Display

| Field | Meaning | Example |
|---|---|---|
| `City Label` | City or region where item is located | `Montreal, QC` |
| `Distance Label` | Approximate distance from search origin (if user has location enabled) | `5 km away` |
| `Listing Display URL` | Direct link to the full listing page | `https://www.lespac.com/v/listing/abc123xyz` |

#### Promotion & Analytics

| Field | Meaning | Example |
|---|---|---|
| `Priority Placement Layout Flag` | Whether listing uses premium/featured layout | `true` if boosted, `false` if organic |
| `Search Page Tracking Info` | Metadata for user interaction tracking | Campaign or source identifier |

***

### How to Use

1. **Find your search URL** — Go to Lespac.com, apply filters (location, category, price range), and copy the full URL from the address bar.
2. **Configure input** — Paste the URL(s) into the `urls` array. Set `max_items_per_url` to control volume (e.g., `200` to get up to 200 items per URL).
3. **Enable error handling** — Set `ignore_url_failures: true` for bulk runs to skip broken links without stopping.
4. **Run the scraper** — Start the actor and monitor progress in the logs.
5. **Export data** — Download results as JSON, CSV, or Excel for analysis, price monitoring, or integration.

**Best practices:**

- Use filtered Lespac URLs to narrow results (e.g., by category, location, price) before scraping.
- Test with a small `max_items_per_url` value first to verify data quality.
- For large-scale operations, run multiple jobs targeting different categories or regions in parallel.
- Store timestamps to identify newly listed items in repeat runs.

***

### Use Cases & Business Value

- **E-commerce price monitoring:** Track competitor pricing on vehicles, electronics, or appliances in real time
- **Market research:** Analyze inventory levels, pricing trends, and demand across regions
- **Real estate analysis:** Monitor property listings, average prices, and time-on-market by neighborhood
- **Lead generation:** Build datasets of sellers for targeted marketing campaigns
- **Data enrichment:** Combine Lespac data with your internal databases for competitive intelligence

The scraper accelerates workflows that would require hours of manual browsing, enabling data-driven decision making.

***

### Conclusion

The **Lespac Product Search Scraper** is a powerful tool for anyone monitoring classified listings at scale. With clean structured output covering 20+ fields—from pricing and descriptions to images and timestamps—it transforms Lespac search results into actionable business intelligence. Whether you're analyzing markets, monitoring competition, or building aggregator platforms, this scraper delivers reliable, up-to-date data efficiently.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.lespac.com/montreal/vehicules-autos_b286g17567k1R2.jsa?ncc=dx0i1irZ006dHJ1ZQis20j0"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.lespac.com/montreal/vehicules-autos_b286g17567k1R2.jsa?ncc=dx0i1irZ006dHJ1ZQis20j0"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/lespac-product-search-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 = {
    "urls": ["https://www.lespac.com/montreal/vehicules-autos_b286g17567k1R2.jsa?ncc=dx0i1irZ006dHJ1ZQis20j0"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/lespac-product-search-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 '{
  "urls": [
    "https://www.lespac.com/montreal/vehicules-autos_b286g17567k1R2.jsa?ncc=dx0i1irZ006dHJ1ZQis20j0"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/lespac-product-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lespac Product Search Scraper",
        "description": "Scrape product listings from Lespac.com search results with precision. Collect titles, prices, descriptions, images, locations, and 20+ metadata fields per item — perfect for price monitoring, market analysis, and classified ad aggregation.",
        "version": "0.0",
        "x-build-id": "JnZPhAY5fVqo0XfIk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~lespac-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-lespac-product-search-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/stealth_mode~lespac-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-lespac-product-search-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/stealth_mode~lespac-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-lespac-product-search-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": {
                    "urls": {
                        "title": "URLs of the product search list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
