# Amazon Seller Data Extractor (`scraperforge/amazon-seller-data-extractor`) Actor

- **URL**: https://apify.com/scraperforge/amazon-seller-data-extractor.md
- **Developed by:** [ScraperForge](https://apify.com/scraperforge) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### 🛒 Amazon Seller Data Extractor Scraper — The Ultimate Tool for Amazon Data Mining

Looking for the best way to extract Amazon seller data at scale? ⚙️  
The Amazon Seller Data Extractor Scraper is your go-to solution for collecting accurate, real-time seller insights directly from Amazon — all within minutes. Whether you’re using it for market research, competitive analysis, or lead generation, this Apify-powered Amazon scraper makes data scraping from Amazon effortless and efficient.

* * *

### 🤔 What does Amazon Seller Data Extractor Scraper do?

The Amazon Seller Data Extractor Scraper is a powerful Amazon data scraping tool built to collect seller-specific data such as store names, business addresses, ratings, reviews, contact details, and more. 🧠

By using this Amazon scraper API, you can automatically extract verified and structured seller information, helping you make data-driven business decisions.

✨ SEO Benefit: Marketers and eCommerce analysts use this scraper to gather high-quality data for competitor tracking, price comparison, and market intelligence, boosting their Amazon SEO strategy and sales optimization.

### 📦 What Amazon Seller Data Extractor Scraper can extract?

Below is a quick overview of the types of data you can extract from Amazon sellers 👇

| 🧾 Data Type | 📘 Description |
| --- | --- |
| Seller ID | Unique identifier of the Amazon seller |
| Store Name | Official seller name as listed on Amazon |
| Business Address | Complete physical address of the seller |
| Contact Info | Phone number or email (if publicly available) |
| Ratings & Reviews | Overall rating score and feedback count |
| Storefront URL | Direct link to seller’s store page |
| About Seller | Business profile and seller description |
| Products Offered | List of best-selling or featured products |
| Country / Domain | Marketplace location (e.g., Amazon.com, Amazon.de) |

🧩 This data can be exported as JSON, CSV, or Excel, making it ideal for integration with your CRM or analytics dashboards.

#### ⚡ Key Features of Amazon Seller Data Extractor Scraper

Here’s what makes this scraper stand out from the rest:

*   🔍 Real-time Amazon Data Extraction: Fetch up-to-date seller information with every run.  
      
    
*   🧠 AI-Driven Accuracy: Powered by advanced Apify Amazon Scraper technology for consistent and accurate results.  
      
    
*   🌍 Multi-Domain Support: Works for all global Amazon marketplaces — US, UK, DE, IN, JP, and more.  
      
    
*   🔄 Proxy Rotation & CAPTCHA Handling: Prevents blocking and ensures smooth scraping at scale.  
      
    
*   🧰 Flexible Integration: Connect with Zapier, Google Sheets, or API endpoints for automation.  
      
    
*   🧾 Customizable Input: Choose specific sellers or categories with JSON configuration.  
      
    
*   🆓 Free & Paid Versions: Try the Amazon Seller Data Extractor Scraper free before upgrading for larger datasets.  
      
    
*   💻 Cross-Platform Use: Works via web, Amazon Scraper Chrome Extension, or Amazon-scraper GitHub repositories.  
      
    

### 🧭 How to Use Amazon Seller Data Extractor Scraper

Follow this easy, step-by-step guide 🪜

1.  Log in to Apify – Create a free account or sign in.  
      
    
2.  Select the Actor – Search for “Amazon Seller Data Extractor Scraper” in the Apify Store.  
      
    
3.  Enter Input Data – Provide seller IDs or product URLs in JSON format.  
      
    
4.  Choose Output Options – Select CSV, Excel, or JSON for exporting data.  
      
    
5.  Run the Scraper – Start extraction; data will be collected automatically.  
      
    
6.  Download Results – Access results from your Apify dataset or via Amazon scraper API integration.  
      
    

💡 Tip: For advanced users, you can automate the process with Amazon scraper Python scripts or trigger runs using Apify API endpoints.

### 🎯 Use Cases

Here’s how businesses are leveraging the Amazon Seller Data Extractor Scraper:

*   📊 Market Research: Identify seller trends, growth patterns, and regional activity.  
      
    
*   💰 Price Monitoring: Track competitor pricing and adjust your offers dynamically.  
      
    
*   🧾 Lead Generation: Build verified seller databases for outreach campaigns.  
      
    
*   🔍 Compliance Checks: Validate seller identities for B2B partnerships.  
      
    
*   🏬 Product Analysis: Discover which sellers dominate certain product categories.  
      
    
*   💼 Vendor Vetting: Evaluate potential suppliers before onboarding.  
      
    

🧠 From startups to enterprise-grade retailers, this Amazon seller scraper powers data-driven decisions and competitive edge.

### 💎 Why Choose Us?

We built the Amazon Seller Data Extractor Scraper for speed, reliability, and simplicity 💪

*   🚀 Fast Performance: Extracts thousands of seller profiles in minutes.  
      
    
*   🧩 High Accuracy: Clean, structured JSON ensures easy integration.  
      
    
*   🌐 Apify Cloud Integration: Runs seamlessly on Apify’s high-availability infrastructure.  
      
    
*   🛡️ Safe & Compliant: Adheres to best practices for ethical web scraping.  
      
    
*   🧠 Expert Support: Backed by a professional data scraping team with years of experience.  
      
    

With constant updates and 24/7 uptime, our scraper is trusted by marketers, analysts, and developers worldwide.

### 📈 How Many Results Can You Scrape?

Scalability is where our scraper shines 🌟

Depending on your input, the Amazon Seller Data Extractor Scraper can return hundreds to thousands of results in a single run.

Performance factors include:

*   Type of input (seller ID vs. category)  
      
    
*   Domain location (Amazon.com vs. Amazon.de)  
      
    
*   Server capacity & proxy configuration  
      
    

🧠 We regularly benchmark our system to maintain high throughput and reliability. For larger datasets, use pagination + Apify API scheduling for continuous data collection.

⚙️ Pro Tip: Want enterprise-grade scalability? Combine our Amazon scraper API with your ETL pipeline or data warehouse for real-time updates.

### ⚖️ Is It Legal to Scrape Amazon?

Scraping publicly available Amazon data (like seller names, ratings, and reviews) is generally legal, as long as it complies with:

*   Amazon’s Terms of Service  
      
    
*   Local data protection laws (like GDPR)  
      
    
*   Ethical scraping guidelines  
      
    

Our scraper is designed to respect these boundaries — it never accesses private or restricted information. Always use scraped data responsibly and for permitted business purposes ✅

### ⚙️ Input Parameters

Example JSON Input:
```json
{
  "startUrls": [
    {
      "url": "https://www.amazon.com/sp?seller=A33W53J5GVPZ8K"
    },
    {
      "url": "https://www.amazon.com/sp?seller=A2N5Q13T20FFT2"
    }
  ],
  "sortOrder": "recent",
  "maxComments": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### 🧾 Output Format

Example JSON Output:

```json
{
  "url": "https://www.amazon.com/sp?seller=A33W53J5GVPZ8K",
  "seller_id": "A33W53J5GVPZ8K",
  "seller_name": "Peckomatic",
  "description": "Peckomatic is committed to providing each customer with the highest standard of customer service.",
  "detailed_info": [
    {
      "title": "Business Name",
      "value": "Francis Kunnumpurath"
    },
    {
      "title": "Business Address",
      "value": "2612 state route 80, 2612 state route 80, Lafayette, NY, 13084, US"
    }
  ],
  "feedbacks": [
    {
      "stars": "5 out of 5 stars",
      "text": "It say not to exceed 10ths total but I did anyway. My bird was 8lbs + the 3lb box equal 11lbs . Bird arrived in great condition.",
      "date": "By Kao y. on November 16, 2021."
    }
  ],
  "stars": "4.5 out of 5 stars",
  "return_policy": [],
  "shipping_policies": "Unless noted otherwise in the ordering pipeline, Peckomatic ships all items within two days of receiving an order...",
  "privacy_security": "Amazon knows that you care how information about you is used and shared...",
  "privacy_policy": "Peckomatic values the privacy of your personal data.",
  "help_content": "For questions about a charge that has been made to your credit card, please contact Amazon...",
  "products_link": "https://www.amazon.com/s?ie=UTF8&marketplaceID=ATVPDKIKX0DER&me=A33W53J5GVPZ8K",
  "rating_positive": "88% positive",
  "feedbacks_percentages": {
    "star_5": "79%",
    "star_4": "10%",
    "star_3": "7%",
    "star_2": "0%",
    "star_1": "5%"
  },
  "rating_count_m12": 0,
  "rating_count_m3": 0,
  "rating_count_lifetime": 42,
  "rating_count_m1": 0,
  "country": "US",
  "timestamp": "2025-11-07T10:11:16.950694Z",
  "seller_phone_number": null
}  
```

### 💬 FAQ

#### 1. Is the Amazon Seller Data Extractor Scraper free?

Yes! 🎁 You can try the Amazon Seller Data Extractor Scraper free on Apify with limited runs.

#### 2. Can I download data as CSV or Excel?

Absolutely. You can download results in CSV, JSON, or Excel formats directly.

#### 3. Does it support all Amazon regions?

Yes — including Amazon.com, Amazon.de, Amazon.co.uk, Amazon.in, and others.

#### 4. Is this scraper available as a Chrome extension?

Yes! You can use the Amazon Scraper Chrome Extension for browser-based scraping.

#### 5. Can I use it via API or Python?

Definitely — access it through Apify Amazon Scraper API or integrate with your Amazon scraper Python scripts.

#### 6. Where can I find open-source versions?

Check Amazon-scraper GitHub repositories for community builds and examples.

#### 7. What’s the price of Amazon Seller Data Extractor Scraper?

The Amazon Seller Data Extractor Scraper price depends on your usage. Start free and scale affordably.

### 🌟 Ready to Extract Data from Amazon?

Try the Amazon Seller Data Extractor Scraper today — automate your data collection, fuel your analytics, and stay ahead of competitors 🚀

👉 Start your free trial on Apify now and transform raw Amazon data into business-ready intelligence!

# Actor input Schema

## `asinInputs` (type: `array`):

List of Amazon ASINs (e.g., B00P8XQPY4). The actor will extract seller information from product pages.

## `usernameInputs` (type: `array`):

List of Amazon seller usernames or seller IDs (e.g., A33W53J5GVPZ8K).

## `keywordInputs` (type: `array`):

List of keywords to search for sellers (e.g., 'electronics seller', 'bookstore').

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

List of Amazon seller page URLs (e.g., https://www.amazon.com/sp?seller=A33W53J5GVPZ8K).

## `amazonDomain` (type: `string`):

Amazon domain to use (e.g., amazon.com, amazon.co.uk, amazon.de).

## `language` (type: `string`):

Language for Amazon pages (e.g., en-US, en-GB, de-DE). Leave empty for default.

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

Country for proxy selection. Use 'AUTO' for automatic selection.

## `useCaptchaSolver` (type: `boolean`):

Enable captcha solver (warning: may incur additional costs).

## `sortOrder` (type: `string`):

Sort order for feedbacks (if applicable). Options: 'recent', 'helpful', 'rating'

## `maxComments` (type: `integer`):

Maximum number of feedback comments to extract per seller (0 = all available).

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

Note: This actor always uses residential proxy regardless of your selection. The proxy configuration option is available for compatibility but will be automatically overridden to use residential proxy.

## Actor input object example

```json
{
  "asinInputs": [
    "B00P8XQPY4"
  ],
  "usernameInputs": [],
  "keywordInputs": [],
  "startUrls": [],
  "amazonDomain": "amazon.com",
  "language": "",
  "proxyCountry": "AUTO",
  "useCaptchaSolver": false,
  "sortOrder": "recent",
  "maxComments": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "asinInputs": [
        "B00P8XQPY4"
    ],
    "usernameInputs": [],
    "keywordInputs": [],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperforge/amazon-seller-data-extractor").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 = {
    "asinInputs": ["B00P8XQPY4"],
    "usernameInputs": [],
    "keywordInputs": [],
    "startUrls": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperforge/amazon-seller-data-extractor").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 '{
  "asinInputs": [
    "B00P8XQPY4"
  ],
  "usernameInputs": [],
  "keywordInputs": [],
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraperforge/amazon-seller-data-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperforge/amazon-seller-data-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Seller Data Extractor",
        "version": "0.1",
        "x-build-id": "8gVptZBZ4FRShteNb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperforge~amazon-seller-data-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperforge-amazon-seller-data-extractor",
                "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/scraperforge~amazon-seller-data-extractor/runs": {
            "post": {
                "operationId": "runs-sync-scraperforge-amazon-seller-data-extractor",
                "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/scraperforge~amazon-seller-data-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-scraperforge-amazon-seller-data-extractor",
                "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": {
                    "asinInputs": {
                        "title": "Enter Amazon ASINs",
                        "type": "array",
                        "description": "List of Amazon ASINs (e.g., B00P8XQPY4). The actor will extract seller information from product pages.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "usernameInputs": {
                        "title": "Enter Seller Usernames",
                        "type": "array",
                        "description": "List of Amazon seller usernames or seller IDs (e.g., A33W53J5GVPZ8K).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywordInputs": {
                        "title": "Enter Keywords",
                        "type": "array",
                        "description": "List of keywords to search for sellers (e.g., 'electronics seller', 'bookstore').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Amazon Seller URLs",
                        "type": "array",
                        "description": "List of Amazon seller page URLs (e.g., https://www.amazon.com/sp?seller=A33W53J5GVPZ8K).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "amazonDomain": {
                        "title": "Amazon domain",
                        "type": "string",
                        "description": "Amazon domain to use (e.g., amazon.com, amazon.co.uk, amazon.de).",
                        "default": "amazon.com"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language for Amazon pages (e.g., en-US, en-GB, de-DE). Leave empty for default.",
                        "default": ""
                    },
                    "proxyCountry": {
                        "title": "Proxy country",
                        "type": "string",
                        "description": "Country for proxy selection. Use 'AUTO' for automatic selection.",
                        "default": "AUTO"
                    },
                    "useCaptchaSolver": {
                        "title": "Use Captcha solver",
                        "type": "boolean",
                        "description": "Enable captcha solver (warning: may incur additional costs).",
                        "default": false
                    },
                    "sortOrder": {
                        "title": "Review sort order",
                        "enum": [
                            "recent",
                            "helpful",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Sort order for feedbacks (if applicable). Options: 'recent', 'helpful', 'rating'",
                        "default": "recent"
                    },
                    "maxComments": {
                        "title": "Maximum reviews per product",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of feedback comments to extract per seller (0 = all available).",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Note: This actor always uses residential proxy regardless of your selection. The proxy configuration option is available for compatibility but will be automatically overridden to use residential proxy."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```