# todocoleccion Marketplace Scraper (`automation-lab/todocoleccion-marketplace-scraper`) Actor

Scrape public todocoleccion lot listings, prices, categories, images, offer flags, and optional seller details for collectible research.

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

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## todocoleccion Marketplace Scraper

Collect public lot listings from todocoleccion search pages for collectible pricing, inventory, and seller research.

### What does todocoleccion Marketplace Scraper do?

This Apify actor extracts public search results from `todocoleccion.net`, a Spanish marketplace for collectibles, antiques, books, toys, comics, coins, postcards, art, and other second-hand lots.

It turns todocoleccion search pages into a structured dataset with lot IDs, titles, URLs, prices, categories, images, offer flags, and optional detail-page seller and description fields.

### Who is it for?

- 🧑‍💼 Resellers tracking market prices for collectible inventory.
- 🏬 Antique and hobby shops monitoring availability by category.
- 📊 Ecommerce analysts comparing asking prices across niches.
- 🧾 Auction researchers building comparable-sales lead lists.
- 🧑‍🎨 Brand and IP owners watching vintage product listings.
- 🧑‍💻 Data teams feeding internal dashboards or alerts.

### Why use it?

Manual marketplace research is slow when you need hundreds or thousands of listings.
This actor automates repeatable collection from public todocoleccion pages and exports data in JSON, CSV, Excel, XML, RSS, or through the Apify API.

### Data you can extract

| Field | Description |
| --- | --- |
| `lotId` | todocoleccion lot identifier |
| `title` | Listing title |
| `url` | Public lot URL |
| `searchUrl` | Search page where the lot was found |
| `priceText` | Displayed price string |
| `price` | Parsed numeric price when available |
| `currency` | Currency code, usually EUR |
| `category` | Visible marketplace category |
| `imageUrl` | Main image URL |
| `saleMode` | Visible sale or offer note |
| `acceptsOffers` | Whether the card mentions offers |
| `seller` | Seller username when detail fetch is enabled |
| `sellerUrl` | Seller profile URL when detail fetch is enabled |
| `sellerSince` | Public seller start date when visible |
| `sellerLocation` | Public seller location when visible |
| `sellerRatingText` | Public rating text when visible |
| `description` | Public lot description when detail fetch is enabled |
| `scrapedAt` | ISO timestamp of extraction |

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

The pricing is pay per event: a small `$0.005` run-start event plus a per-result event.
Cloud validation set the BRONZE result price to about `$0.18 per 1,000 listing results`, with automatic tier discounts for higher Apify plans.

### Input options

Use keyword searches, full search URLs, or both.

- `searchQueries` — keywords such as `star wars`, `monedas`, `postales antiguas`, or `playmobil`.
- `searchUrls` — full todocoleccion search/category URLs with filters already applied.
- `maxItems` — total number of lots to save.
- `maxPages` — number of result pages to scan per search.
- `fetchDetails` — enrich each lot with seller and description fields.
- `proxyConfiguration` — optional Apify proxy settings.
- `maxRequestRetries` — retry count for HTTP requests.

### Example input

```json
{
  "searchQueries": ["star wars"],
  "maxItems": 30,
  "maxPages": 2,
  "fetchDetails": false,
  "proxyConfiguration": { "useApifyProxy": false },
  "maxRequestRetries": 3
}
````

### Example with detail pages

```json
{
  "searchQueries": ["monedas romanas"],
  "maxItems": 25,
  "maxPages": 2,
  "fetchDetails": true
}
```

Detail mode is slower because every lot page is opened after the search result page.
Use it when seller profile, location, rating text, or description matters.

### Using search URLs

Paste a filtered todocoleccion URL when you want to preserve marketplace filters.
For example, create a search in your browser, apply category or sorting filters, then copy the URL into `searchUrls`.

```json
{
  "searchUrls": ["https://www.todocoleccion.net/buscador?bu=star%20wars&O=rl"],
  "maxItems": 60,
  "maxPages": 3
}
```

### Output example

```json
{
  "lotId": "680557595",
  "title": "CINEMANIA. STAR WARS EPISODIO II...",
  "url": "https://www.todocoleccion.net/libros-segunda-mano-cine/...~x680557595",
  "searchUrl": "https://www.todocoleccion.net/buscador?bu=star+wars&O=rl",
  "priceText": "1,00 €",
  "price": 1,
  "currency": "EUR",
  "category": "Libros de Cine de segunda mano",
  "acceptsOffers": false,
  "scrapedAt": "2026-05-18T00:00:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Enter one or more keywords or URLs.
3. Set a conservative `maxItems` value for the first run.
4. Enable detail pages only if you need enriched fields.
5. Click **Start**.
6. Download the dataset or consume it through the API.

### Tips for better results

- 🔎 Use Spanish marketplace terms for the best coverage.
- 📏 Start with 30 to 100 lots before scaling up.
- 🧩 Use category-filtered URLs for narrow niches.
- ⚙️ Turn on detail pages only for enriched seller and description data.
- 🧹 Deduplicate downstream by `lotId` if you run overlapping searches.

### Integrations

Use this actor in workflows such as:

- Daily price monitoring for collectible SKUs.
- Seller-discovery dashboards for niche categories.
- Alerting pipelines when new lots match a brand or character.
- Research notebooks comparing asking prices across searches.
- Inventory sourcing spreadsheets for resale teams.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/todocoleccion-marketplace-scraper').call({
  searchQueries: ['star wars'],
  maxItems: 30,
  maxPages: 2
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/todocoleccion-marketplace-scraper').call(run_input={
    'searchQueries': ['star wars'],
    'maxItems': 30,
    'maxPages': 2,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~todocoleccion-marketplace-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["star wars"],"maxItems":30,"maxPages":2}'
```

### MCP integration

Use Apify MCP when you want Claude to run this actor directly from a chat or coding session.
Enable only this tool so prompts route to the correct scraper:

```text
https://mcp.apify.com/?tools=automation-lab/todocoleccion-marketplace-scraper
```

Claude Code setup:

```bash
claude mcp add apify-todocoleccion https://mcp.apify.com/?tools=automation-lab/todocoleccion-marketplace-scraper
```

Claude Desktop or other MCP client JSON configuration:

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

Example prompts for MCP usage:

- "Run automation-lab/todocoleccion-marketplace-scraper for 50 Star Wars lots and summarize the price range."
- "Use the todocoleccion scraper to find Playmobil lots and group them by category."
- "Scrape vintage postcards with seller details enabled and return the most interesting low-price lots."

### Data quality notes

The actor reads public HTML shown on todocoleccion pages.
Some fields are optional because todocoleccion does not display every attribute for every listing.
For example, seller details and descriptions require `fetchDetails: true`.

### Performance notes

Search result mode is fast because it uses HTTP requests and parses server-rendered HTML.
Detail mode is slower because it opens each lot page.
For large monitoring jobs, run search-result mode first and enable detail mode only for selected niches.

### Proxy notes

Direct HTTP is the default because public search pages are reachable without a proxy in current tests.
If you run at higher volume or from restricted networks, enable Apify Proxy in the input.

### Legality

This actor extracts publicly available marketplace data.
You are responsible for using the data in accordance with applicable laws, marketplace terms, and privacy obligations.
Avoid scraping private account data, bypassing access controls, or using the output for spam.

### Troubleshooting: I got fewer items than requested

The source search may have fewer visible lots, filters may narrow the result set, or `maxPages` may be too low.
Increase `maxPages`, try a broader keyword, or paste a different search URL.

### Troubleshooting: Detail fields are empty

Enable `fetchDetails` to collect seller and description fields.
Some lots still may not expose every field publicly.

### FAQ

#### Does it require a todocoleccion account?

No. The actor targets public search and lot pages only.

#### Can it scrape sold prices?

The current MVP focuses on public active search listings and visible lot detail data.

#### Can I scrape multiple searches in one run?

Yes. Add multiple strings to `searchQueries` or multiple URLs to `searchUrls`.

#### How do I avoid duplicates?

The actor deduplicates lots inside one run by `lotId`.
For multiple scheduled runs, deduplicate downstream by `lotId` and timestamp.

### Related scrapers

Other automation-lab actors that may complement this workflow:

- https://apify.com/automation-lab/ebay-search-scraper
- https://apify.com/automation-lab/facebook-marketplace-scraper
- https://apify.com/automation-lab/etsy-scraper
- https://apify.com/automation-lab/amazon-search-scraper

### Changelog

- Initial version: public todocoleccion search scraping with optional detail-page enrichment.

### Support

If a public todocoleccion page shape changes or you need an additional output field, open an Apify issue with your input and expected result.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search on todocoleccion, for example collectible brands, artists, toys, comics, books, coins, or antiques.

## `searchUrls` (type: `array`):

Optional full todocoleccion URLs such as https://www.todocoleccion.net/buscador?bu=star%20wars or category-filtered search pages.

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

Maximum number of lot listings to save across all searches.

## `maxPages` (type: `integer`):

Maximum todocoleccion result pages to scan for each search query or URL. Result pages currently show about 30 lots each.

## `fetchDetails` (type: `boolean`):

Open every lot page to enrich results with public seller, seller location, rating text, and description. Slower but more complete.

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

Optional Apify proxy settings. Direct requests are used when this is empty.

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

Number of retry attempts for failed HTTP requests.

## Actor input object example

```json
{
  "searchQueries": [
    "star wars"
  ],
  "searchUrls": [],
  "maxItems": 20,
  "maxPages": 2,
  "fetchDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRequestRetries": 3
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchQueries": [
        "star wars"
    ],
    "searchUrls": [],
    "maxItems": 20,
    "maxPages": 2,
    "fetchDetails": false,
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/todocoleccion-marketplace-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 = {
    "searchQueries": ["star wars"],
    "searchUrls": [],
    "maxItems": 20,
    "maxPages": 2,
    "fetchDetails": False,
    "proxyConfiguration": { "useApifyProxy": False },
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/todocoleccion-marketplace-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 '{
  "searchQueries": [
    "star wars"
  ],
  "searchUrls": [],
  "maxItems": 20,
  "maxPages": 2,
  "fetchDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRequestRetries": 3
}' |
apify call automation-lab/todocoleccion-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "todocoleccion Marketplace Scraper",
        "description": "Scrape public todocoleccion lot listings, prices, categories, images, offer flags, and optional seller details for collectible research.",
        "version": "0.1",
        "x-build-id": "YM1mKaBDLrGBpN340"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~todocoleccion-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-todocoleccion-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~todocoleccion-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-todocoleccion-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~todocoleccion-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-todocoleccion-marketplace-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": {
                    "searchQueries": {
                        "title": "🔎 Search keywords",
                        "type": "array",
                        "description": "Keywords to search on todocoleccion, for example collectible brands, artists, toys, comics, books, coins, or antiques.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "todocoleccion search/category URLs",
                        "type": "array",
                        "description": "Optional full todocoleccion URLs such as https://www.todocoleccion.net/buscador?bu=star%20wars or category-filtered search pages.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum lots",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of lot listings to save across all searches.",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum todocoleccion result pages to scan for each search query or URL. Result pages currently show about 30 lots each.",
                        "default": 5
                    },
                    "fetchDetails": {
                        "title": "Fetch lot detail pages",
                        "type": "boolean",
                        "description": "Open every lot page to enrich results with public seller, seller location, rating text, and description. Slower but more complete.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Direct requests are used when this is empty."
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed HTTP requests.",
                        "default": 3
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```