# Ebay Scraper (`scraper-engine/ebay-scraper`) Actor

🛒 eBay Scraper (ebay-scraper) extracts structured eBay data: titles, prices, photos, item specifics, sellers, shipping, bids, Buy It Now, sold/completed listings & reviews. 🔎 Ideal for product research, price tracking & competitor analysis. ⚡ Fast, reliable, CSV/JSON exports.

- **URL**: https://apify.com/scraper-engine/ebay-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Ebay Scraper

The Ebay Scraper is an Apify-powered eBay web scraping tool that turns public eBay listings into clean, structured records for analysis and automation. It solves the manual overhead of collecting product details by acting as an eBay data scraper and eBay product scraper that can scrape eBay listings from both search result pages and individual item pages. Built for marketers, developers, data analysts, and researchers, it enables large-scale product research, price tracking, and marketplace monitoring with reliable outputs.

### What data / output can you get?

The actor saves structured JSON to the Apify dataset for each product. Here are the core fields you’ll get when you use this eBay product data extractor:

| Data type | Description | Example value |
| --- | --- | --- |
| url | Canonical listing URL | https://www.ebay.com/itm/123456789012 |
| itemNumber | eBay item ID parsed from URL or metadata | 123456789012 |
| title | Main product title | NordicTrack T 6.5 S Folding Treadmill |
| priceWithCurrency | Current price with currency label | US $299.99 |
| wasPriceWithCurrency | Strikethrough/previous price (if present) | US $349.99 |
| available | Quantity available (parsed from buy box/availability text) | 5 |
| availableText | Human-readable availability text | 5 available |
| sold | Items sold (parsed from buy box region) | 127 |
| image | Primary product image URL | https://i.ebayimg.com/images/g/abc/s-l1600.jpg |
| seller | Seller username or store name | top-seller-store |
| itemLocation | Item location text | Los Angeles, California, United States |
| brand | Brand parsed from item specifics (defaults to “Unbranded” if missing) | NordicTrack |

Bonus fields saved alongside the above:
- subTitle: Additional subtitle/description text if present
- price: Numeric price (float)
- wasPrice: Numeric “was” price (float)
- categories: Breadcrumb/category trail
- upc, ean, mpn: Product identifiers from item specifics
- whyToBuy: Highlights from shipping/benefits sections

You can export your dataset to JSON or CSV directly from Apify. This makes the actor a practical eBay listing scraper and eBay price scraper for downstream analytics and automation.

### Key features

- 🔎 Bold discovery from search results
  Extracts product links from eBay search and category pages by targeting s-item__link anchors, falling back to robust patterns, and normalizing to https://www.ebay.com/itm/<id>. Perfect when you want to scrape eBay listings at scale from search results.

- 🧠 Accurate product parsing
  HTML parsing fuses JSON-LD, buy-box regions, and item specifics to capture titles, prices, availability, sold counts, seller, item location, and identifiers (UPC/EAN/MPN). This precision makes it a reliable eBay product data extractor.

- 🧰 Browser-like requests for higher fidelity
  Uses impit with Chrome-like TLS/HTTP fingerprinting and realistic headers to reduce blocks and improve success rates across eBay’s endpoints.

- 🛰️ Smart proxy fallback strategy
  Starts direct (no proxy), then automatically falls back to Apify datacenter (group SHADER) and residential (group RESIDENTIAL) proxies if blocked. After a successful residential fetch, switches to “sticky” residential for subsequent requests.

- ⚡ Concurrent fetches with optional delay
  Runs multiple product fetches in parallel with a small randomized delay between requests for stability. Ideal as an eBay data crawler for large batches.

- 💾 Structured output, CSV/JSON exports
  Pushes one structured record per product directly into your Apify dataset. Export to CSV or JSON in a click for your BI tools and pipelines.

- 🐍 Developer-friendly, Apify SDK for Python
  Built with the Apify SDK for Python and streams results as they’re processed. Great for “eBay scraper Python” workflows and API-driven pipelines.

- 🛡️ Resilient and production-ready
  Detects blocks and retries intelligently. Clear logging shows discovery progress, saves, and any placeholder rows in case of temporary issues.

### How to use Ebay Scraper - step by step

1. Create or sign in to your Apify account.
2. Open the Ebay Scraper actor on your Apify dashboard.
3. Add input URLs in the urls field:
   - Paste eBay search/category URLs (contain “/sch/” or “i.html”) to discover multiple products.
   - Paste direct item URLs (contain “/itm/…”) for laser-focused scraping.
4. Optionally set maxItems to cap how many discovered products you process in a run (0 means no limit).
5. (Optional) Configure proxyConfiguration:
   - useApifyProxy: true to enable automatic fallback to datacenter/residential proxies.
   - apifyProxyCountry (or countryCode) for geo-targeting when needed.
6. Start the actor. The run will:
   - Discover product links from your search URLs and/or add the item URLs you provided.
   - Fetch each product’s page and push structured records to the dataset in real time.
7. Monitor progress in the run logs. The actor logs each save with item number, title, price, and seller snapshot.
8. Export your results from the dataset as JSON or CSV for analysis or integration.

Pro tip: Use search results URLs to cast a wide net, then iterate with maxItems for samples and budget control. For pipeline automation, access your dataset via Apify API or integrate with your “eBay inventory scraper” workflows in Python.

### Use cases

| Use case name | Description |
| --- | --- |
| Price tracking for retail | Monitor price and was-price across listings, turning the actor into a dependable eBay price scraper for dynamic pricing and promotions. |
| Product research & catalog building | Enrich product catalogs with titles, images, brand, and identifiers using this eBay product scraper for bulk SKU onboarding. |
| Competitor analysis & seller insights | Benchmark seller names, locations, sold counts, and availability to inform marketplace strategy with an eBay seller data extractor approach. |
| Inventory monitoring at scale | Track “available” and “sold” signals across categories as an eBay inventory scraper to spot stock trends and demand. |
| Category trend analysis | Use categories and pricing to analyze trends and build dashboards, powered by an eBay data crawler that exports to CSV/JSON. |
| Data enrichment & API pipelines | Pull structured product records into internal systems, using the Apify dataset/API in Python for downstream processing. |
| Academic & market research | Scrape eBay listings for publicly available data to study pricing behavior, market segments, or product attributes at scale. |

### Why choose Ebay Scraper?

- 🎯 Precision-first extraction of real product signals (title, price, availability, sold, seller, location, identifiers).
- ⚡ Scales from quick samples to large batches with efficient parallelization and discovery from search results.
- 🧪 Developer-ready: built on the Apify SDK for Python, with easy export to CSV or JSON and straightforward API access.
- 🛰️ Robust against blocks thanks to a staged, sticky proxy strategy (direct → SHADER → RESIDENTIAL).
- 🧩 Clean, structured outputs you can feed into analytics, BI, or enrichment pipelines without heavy post-processing.
- 🛡️ Production-ready reliability: resilient fetching, clear logging, and graceful placeholder rows for transient failures.
- 💸 More reliable than brittle browser extensions and generic tools—no flaky UIs or manual copy-paste.

In short: a focused eBay scraping software solution that combines accuracy, scalability, and developer ergonomics.

### Is it legal / ethical to use Ebay Scraper?

Yes—when done responsibly. This actor collects publicly visible listing information and does not require login or access to private data.

Guidelines for compliant use:
- Only scrape public eBay pages and fields.
- Respect eBay’s terms of service and applicable laws (e.g., GDPR, CCPA).
- Avoid collecting or using personal data in ways that violate privacy regulations.
- Use proxies responsibly and throttle appropriately for stability.
- Consult your legal team for edge cases or regulatory questions in your jurisdiction.

### Input parameters & output format

#### Example JSON input
```json
{
  "urls": [
    "https://www.ebay.com/sch/i.html?_nkw=massage+chair&_sacat=6024",
    "https://www.ebay.com/itm/123456789012"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}
````

#### Parameters

| Parameter | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| urls | array | Yes | — | One or many eBay links. Supports search/category pages for discovery and direct /itm/ listing URLs for single-item extraction. |
| maxItems | integer | No | 20 | Cap how many product pages to process after discovery. Use 0 for no limit. |
| proxyConfiguration | object | No | useApifyProxy: true (prefill) | Optional Apify Proxy settings. Supports useApifyProxy and apifyProxyCountry (or countryCode) for geo-targeting. |

Advanced (read by the actor if provided via API):

- concurrency: Parallel product fetches (1–50; default 20).
- requestDelaySeconds: Base delay between requests with small random jitter (default 1).

#### Example JSON output (success)

```json
{
  "url": "https://www.ebay.com/itm/123456789012",
  "categories": [
    "Sporting Goods",
    "Fitness, Running & Yoga",
    "Treadmills"
  ],
  "itemNumber": "123456789012",
  "title": "NordicTrack T 6.5 S Folding Treadmill",
  "subTitle": "SpaceSaver design, iFit compatible",
  "whyToBuy": [
    "Free shipping",
    "30-day returns"
  ],
  "price": 299.99,
  "priceWithCurrency": "US $299.99",
  "wasPrice": 349.99,
  "wasPriceWithCurrency": "US $349.99",
  "available": 5,
  "availableText": "5 available",
  "sold": 127,
  "image": "https://i.ebayimg.com/images/g/abc/s-l1600.jpg",
  "seller": "top-seller-store",
  "itemLocation": "Los Angeles, California, United States",
  "ean": "1234567890123",
  "mpn": "NTL-65S",
  "upc": "Does not apply",
  "brand": "NordicTrack",
  "type": "Treadmill"
}
```

#### Example JSON output (placeholder on failure)

```json
{
  "url": "https://www.ebay.com/itm/123456789012",
  "error": "unavailable"
}
```

Notes:

- Some fields may be null or empty when not present on the page (e.g., ean, mpn, wasPrice). The upc field normalizes missing/NA values to “Does not apply”. The brand field defaults to “Unbranded” when no brand is found.

### FAQ

#### Do I need to log in to use this eBay scraper?

No. The actor works on publicly available eBay pages and does not require login or cookies to extract listing data.

#### Can I scrape eBay search results and individual listings?

Yes. You can provide both search/category URLs (to discover product links) and direct /itm/ listing URLs (to extract a single product). The discovery step normalizes links and de-duplicates them automatically.

#### What fields does the Ebay Scraper return?

It returns structured product data including title, price and was-price, availability and sold counts, seller, item location, image URL, brand, type, categories, and identifiers (UPC/EAN/MPN). See the Output section for the full JSON example.

#### How does the scraper handle blocking and reliability?

It starts without a proxy, then falls back to Apify datacenter (group SHADER) and residential (group RESIDENTIAL) proxies if blocked. After a successful residential request, it stays on residential for subsequent requests to improve stability.

#### How fast is it? Can it scale to many listings?

The actor discovers links from search pages and fetches product pages in parallel with a small delay and jitter for stability. It’s built for batch runs and can act as an eBay data crawler for large-scale collections.

#### Can I use this with Python or via API?

Yes. The actor is built with the Apify SDK for Python and streams results into an Apify dataset you can access via the Apify API. This works well for “eBay scraper Python” integrations and automated workflows.

#### Which export formats are supported?

You can export results from the Apify dataset in JSON or CSV. This makes it straightforward to integrate with BI tools, spreadsheets, or databases.

#### Does it support international listings and different languages?

Yes. The extractor handles multiple UI patterns and captures availability/sold signals in English and Spanish. You can also set apifyProxyCountry (or countryCode) in proxyConfiguration for geo-targeting through Apify Proxy.

### Closing CTA / Final thoughts

Ebay Scraper is built to deliver accurate, structured eBay product data at scale. It helps marketers, developers, analysts, and researchers collect titles, prices, availability, sold counts, sellers, locations, and identifiers—then export to JSON or CSV with ease. Use it to power eBay search results scraping, product research, price tracking, and competitor benchmarking. Developers can plug the Apify dataset/API into Python pipelines for end-to-end automation. Start extracting smarter marketplace insights with a fast, reliable eBay listing scraper that’s ready for production.

# Actor input Schema

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

🗺️ Add one or many eBay links — mix & match as you like!

🔎 Search / category pages → we’ll discover products from the results grid.

🏷️ Single listing pages → we’ll grab that item’s full details.

✅ Paste full URLs from your browser; that’s all you need to get started.

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

📊 Set a ceiling on how many product pages to process after URL discovery — great for quick samples or budget-friendly runs.

0️⃣ Use 0 for no limit (go as far as your inputs allow).

⚡ Lower = faster & lighter; higher = broader coverage.

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

🛡️ Optional Apify Proxy settings for smoother runs when the target site is picky about traffic.

✨ Tune country or groups in the proxy editor if your use case needs it — especially for international or large-scale jobs.

💚 Leave defaults if you’re unsure; you can always rerun with adjustments.

## Actor input object example

```json
{
  "urls": [
    "https://www.ebay.com/sch/i.html?_from=R40&_trksid=p2499334.m570.l1313&_nkw=massage%2Brecliner%2Bchair&_sacat=6024"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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.ebay.com/sch/i.html?_from=R40&_trksid=p2499334.m570.l1313&_nkw=massage%2Brecliner%2Bchair&_sacat=6024"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/ebay-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.ebay.com/sch/i.html?_from=R40&_trksid=p2499334.m570.l1313&_nkw=massage%2Brecliner%2Bchair&_sacat=6024"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/ebay-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.ebay.com/sch/i.html?_from=R40&_trksid=p2499334.m570.l1313&_nkw=massage%2Brecliner%2Bchair&_sacat=6024"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scraper-engine/ebay-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ebay Scraper",
        "description": "🛒 eBay Scraper (ebay-scraper) extracts structured eBay data: titles, prices, photos, item specifics, sellers, shipping, bids, Buy It Now, sold/completed listings & reviews. 🔎 Ideal for product research, price tracking & competitor analysis. ⚡ Fast, reliable, CSV/JSON exports.",
        "version": "1.0",
        "x-build-id": "NdQTPpq5klLomEieq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~ebay-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-ebay-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/scraper-engine~ebay-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-ebay-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/scraper-engine~ebay-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-ebay-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "Where should we look?",
                        "type": "array",
                        "description": "🗺️ Add one or many eBay links — mix & match as you like!\n\n🔎 Search / category pages → we’ll discover products from the results grid.\n\n🏷️ Single listing pages → we’ll grab that item’s full details.\n\n✅ Paste full URLs from your browser; that’s all you need to get started.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Cap how many products to collect",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "📊 Set a ceiling on how many product pages to process after URL discovery — great for quick samples or budget-friendly runs.\n\n0️⃣ Use 0 for no limit (go as far as your inputs allow).\n\n⚡ Lower = faster & lighter; higher = broader coverage.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Connection & reliability (optional)",
                        "type": "object",
                        "description": "🛡️ Optional Apify Proxy settings for smoother runs when the target site is picky about traffic.\n\n✨ Tune country or groups in the proxy editor if your use case needs it — especially for international or large-scale jobs.\n\n💚 Leave defaults if you’re unsure; you can always rerun with adjustments."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
