# Alibaba Email Scraper (`scrapapi/alibaba-email-scraper`) Actor

🛍️ Alibaba Email Scraper extracts publicly available supplier emails from Alibaba listings and profiles. 📧 Fast, accurate lead capture with filters, de-duplication, and CSV export. 🚀 Ideal for B2B outreach, sourcing, and sales prospecting.

- **URL**: https://apify.com/scrapapi/alibaba-email-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 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

### Alibaba Email Scraper

Alibaba Email Scraper is a focused email scraping tool that finds publicly available supplier emails from Alibaba pages indexed on Google — fast. It solves the “where are the supplier emails?” problem by combining targeted site:alibaba.com searches with smart enrichment to capture addresses reliably. Built for marketers, developers, data analysts, and researchers, this Alibaba email extractor streamlines B2B sourcing, outreach, and list building at scale.

### What data / output can you get?

The actor streams structured results to the Apify dataset as soon as they’re found. Each item includes the following fields:

| Data type | Description | Example value |
| --- | --- | --- |
| network | Network label derived from the selected platform | "Alibaba.com" |
| keyword | The keyword that triggered the result | "marketing" |
| title | Result title from the Google SERP block | "ABC Co., Ltd. – Supplier Profile | Alibaba.com" |
| description | SERP snippet text (may be empty if not present) | "Contact ABC Co., Ltd.… email: sales@abc-co.com…" |
| url | Direct link to the Alibaba page found in results | "https://www.alibaba.com/product-detail/…" |
| email | Extracted email address (from SERP or landing page) | "sales@abc-co.com" |

Notes:
- Results are saved to the Apify Dataset. You can export to JSON, CSV, or Excel from the Dataset UI or via API.
- Description may be empty if the Google snippet doesn’t include one. The actor only pushes rows that contain an email.

### Key features

- ✨ Smart Alibaba-focused capture
  Combines a site:alibaba.com query with keyword and optional location filters to scrape emails from Alibaba listings and profiles. Works as an Alibaba supplier email scraper and Alibaba contact email scraper without logins.

- 📨 Email enrichment from landing pages
  If the Google snippet doesn’t expose an email, the actor fetches the result URL and tries to extract an email directly from the landing page — boosting hit rates for your Alibaba email finder workflows.

- 🎯 Precise filters (domains & location)
  Use emailDomains to keep only specific domains (e.g., "@company.com") and location to refine searches. Great for targeted Alibaba leads extractor and Alibaba vendor email scraper campaigns.

- 🔢 Per-keyword result caps
  Control depth with maxEmails. Stop exactly when you’ve collected enough addresses for each keyword to keep runs fast and focused.

- 🛡️ Resilient proxy strategy
  Honors proxyConfiguration if you provide one, otherwise automatically uses the Apify GOOGLE_SERP proxy group. Retries up to 3 times per request with fresh sessions to handle blocks.

- ⚡ Async, fast, and reliable
  Built on aiohttp and asyncio for performance; de-duplicates result URLs per page to avoid noise during your Alibaba email scraping tool runs.

- 📡 Real-time streaming to dataset
  Each found email is pushed immediately via Actor.push_data for faster feedback loops and downstream automations (Zapier/Make/n8n via Apify integrations).

- 🧑‍💻 Developer-friendly on Apify
  Access run outputs via the Apify API, schedule recurring runs, and plug the dataset into your enrichment or CRM pipeline — ideal for an automated Alibaba email list builder.

- 🔒 No login, no extension
  Works from public web results; no cookies, accounts, or Alibaba email scraper Chrome extension required.

### How to use Alibaba Email Scraper - step by step

1. Create or log in to your Apify account.
2. Open the Alibaba Email Scraper actor and go to the Input tab.
3. Add your keywords (array of strings). These drive the site:alibaba.com searches.
4. (Optional) Set filters:
   - emailDomains: keep only emails from these domains.
   - location: narrow your search by city/country.
   - maxEmails: cap results per keyword (default: 20).
   - platform: defaults to "Alibaba".
   - engine: defaults to "legacy".
   - proxyConfiguration: use your own proxy or rely on the built-in GOOGLE_SERP group.
5. Click Start to run the actor. The run logs will show progress by keyword and collection status.
6. As emails are found, items stream to the Dataset in real time.
7. When the run finishes, open the Dataset tab to preview results and export to JSON, CSV, or Excel.

Pro Tip: Use Apify’s API to fetch the dataset programmatically and sync new emails to your CRM or outreach tools for automated Alibaba supplier contact extractor workflows.

### Use cases

| Use case name | Description |
| --- | --- |
| Sales teams – Alibaba B2B email scraper | Build targeted outreach lists by scraping emails from Alibaba suppliers aligned to your keywords and regions. |
| Sourcing managers – supplier discovery | Identify and contact manufacturers/distributors faster with a focused Alibaba supplier email scraper. |
| Agencies – campaign list building | Assemble clean email lists for campaigns using domain filters for brand-safe targeting. |
| Founders & growth hackers – quick validation | Validate markets with fast contact capture; ideal Alibaba email list builder for MVP outreach. |
| Researchers & analysts – market mapping | Collect contacts and URLs for supplier landscape analyses and academic research. |
| Developers – API-based enrichment | Automate email capture pipelines by pulling dataset items via the Apify API for downstream processing. |

### Why choose Alibaba Email Scraper?

A precise, automation-ready Alibaba email extractor built for reliability at scale.

- ✅ Accurate, Alibaba-only targeting: Uses site:alibaba.com filtering for highly relevant results.
- ⚡ Fast & scalable: Async requests and per-keyword limits keep jobs efficient and predictable.
- 🧩 Developer access: Runs on Apify with API endpoints for seamless integration into pipelines.
- 🔐 Safe & responsible: Scrapes public pages/snippets without logins or cookies.
- 🛠️ Robust infrastructure: Built-in fallback to the GOOGLE_SERP proxy group with retries to reduce blocks.
- 💸 Extension-free alternative: More stable than fragile browser extensions; no desktop runtime required.
- 🔄 Automation-ready: Stream results to datasets for Zapier/Make/n8n workflows and CRM syncs.

Bottom line: a production-minded Alibaba email scraping tool that outperforms manual copy-paste and unstable extensions.

### Is it legal / ethical to use Alibaba Email Scraper?

Yes — when used responsibly. This actor targets publicly available content found via Google and does not access private or authenticated data.

Guidelines for compliant use:
- Scrape and use only public information and respect Alibaba’s terms of service.
- Ensure your outreach complies with applicable laws (e.g., GDPR, CCPA).
- Avoid collecting or using personal data without a lawful basis.
- Verify your specific use case with your legal team if in doubt.

### Input parameters & output format

Example JSON input
```json
{
  "keywords": ["marketing", "founder"],
  "platform": "Alibaba",
  "location": "Germany",
  "emailDomains": ["@company.com", "@gmail.com"],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Input parameters

- keywords (array, required): Add the keywords you want to target on Alibaba. The actor searches Google for Alibaba profiles/posts matching these keywords and extracts email addresses. Default: none.
- platform (string, optional): Choose the platform you want to scrape. Currently supports "Alibaba". Default: "Alibaba".
- location (string, optional): Optional location filter to narrow the search (e.g., "London", "Germany"). Default: "".
- emailDomains (array, optional): Optional domain filter to keep only specific email domains (e.g., "@company.com"). Default: none.
- maxEmails (integer, optional): How many emails to collect per keyword. Minimum: 1, Maximum: 5000. Default: 20.
- engine (string, optional): Scraping engine style. Supported: "legacy". Default: "legacy".
- proxyConfiguration (object, optional): Configure proxies. By default, if none is provided, the actor attempts the Apify GOOGLE\_SERP proxy group and falls back gracefully. Default prefill: {"useApifyProxy": false}.

Example JSON output

```json
[
  {
    "network": "Alibaba.com",
    "keyword": "marketing",
    "title": "ACME Manufacturing Co. – Company Profile | Alibaba.com",
    "description": "Contact ACME Manufacturing Co.… Email: sales@acme-mfg.com …",
    "url": "https://www.alibaba.com/product-detail/industrial-widget-123.html",
    "email": "sales@acme-mfg.com"
  },
  {
    "network": "Alibaba.com",
    "keyword": "founder",
    "title": "XYZ Trading Ltd – Supplier Profile | Alibaba.com",
    "description": "",
    "url": "https://www.alibaba.com/company/xyz-trading-ltd",
    "email": "info@xyztrading.com"
  }
]
```

Notes:

- The actor only pushes rows that include an email.
- description may be empty if the snippet doesn’t include one.

### FAQ

#### Do I need a login or cookies to use this Alibaba email scraper?

No. The actor works from publicly available pages indexed on Google and does not require logins, cookies, or session data. It’s an extension-free Alibaba email scraping tool built for reliability.

#### How does it find supplier emails from Alibaba?

The actor runs targeted Google searches using site:alibaba.com plus your keywords and optional location. It extracts emails from the SERP snippet when present, and if not found, it fetches the landing page to extract one — making it a practical Alibaba email finder.

#### Can I filter results by email domain or location?

Yes. Use emailDomains to restrict emails to domains you care about (e.g., "@company.com") and location to bias results toward a city/country. This helps build cleaner lists with an Alibaba supplier contact extractor workflow.

#### How many emails can it collect per keyword?

You control this with maxEmails. The default is 20, and you can set it between 1 and 5000 per keyword to balance depth and speed.

#### What output fields do I get?

Each dataset item includes: network, keyword, title, description, url, and email. The actor only pushes rows that contain an email address.

#### Does it support proxies for Google SERP scraping?

Yes. You can provide proxyConfiguration. If none is supplied, the actor automatically attempts the Apify GOOGLE\_SERP proxy group and retries up to 3 times per request. It falls back gracefully to keep your run going.

#### Is this an Alibaba email scraper Chrome extension?

No. It’s an Apify actor (server-side) — more stable and scalable than a browser extension. If you’ve outgrown extension-based tools, this is a robust alternative.

#### Where do results go and how can I export them?

Results stream to the Apify Dataset during the run. From there, you can download or programmatically access them in JSON, CSV, or Excel for your Alibaba company email scraper workflows.

### Closing CTA / Final thoughts

Alibaba Email Scraper is built to extract targeted, public supplier emails from Alibaba pages quickly and reliably. With precise filters, landing-page enrichment, and resilient proxy handling, it’s ideal for marketers, developers, data analysts, and researchers who need clean contact lists fast.

Run it on Apify to automate your Alibaba B2B email scraper pipeline, export structured results to CSV/JSON/Excel, and integrate via API into your CRM or enrichment stack. Start extracting smarter, targeted Alibaba contacts and accelerate your outreach today.

# Actor input Schema

## `keywords` (type: `array`):

Add the keywords you want to target on Alibaba (e.g., \['marketing', 'founder', 'business']). 🧠 The actor will search Google for Alibaba profiles/posts matching these keywords and automatically extract email addresses for you. 📧

## `platform` (type: `string`):

Choose the platform you want to scrape. For now this actor focuses on Alibaba for highly targeted B2B leads. 🏬

## `location` (type: `string`):

Optional but powerful: narrow down your search by location (e.g., 'London', 'New York', 'Germany'). 🌍 Leave empty to search worldwide and reach a global audience.

## `emailDomains` (type: `array`):

Optional: Only keep emails from the domains you care about (e.g., \['@gmail.com', '@outlook.com', '@company.com']). 🎯 Leave empty if you want to collect every valid email we find.

## `maxEmails` (type: `integer`):

Set how many emails you want per keyword (default: 20). 📊 Increase for deeper scraping, or lower it for quick, focused batches.

## `engine` (type: `string`):

Pick your scraping engine style. 🚀 Cost Effective (New): Blazing‑fast async requests with residential proxies for cheaper, scalable scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors — ultra‑reliable but a bit slower and pricier.

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

Control how your requests are routed. 🌐 By default, no proxy is used. If Google starts blocking or rejecting requests, the actor will automatically retry using datacenter proxies and then residential proxies (up to 3 retries) to keep your scraping running smoothly. 🔄

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Alibaba",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "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 = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapapi/alibaba-email-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 = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapapi/alibaba-email-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 '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapapi/alibaba-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Alibaba Email Scraper",
        "description": "🛍️ Alibaba Email Scraper extracts publicly available supplier emails from Alibaba listings and profiles. 📧 Fast, accurate lead capture with filters, de-duplication, and CSV export. 🚀 Ideal for B2B outreach, sourcing, and sales prospecting.",
        "version": "0.1",
        "x-build-id": "MQFgAOD93WA1AD8rV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~alibaba-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-alibaba-email-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/scrapapi~alibaba-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-alibaba-email-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/scrapapi~alibaba-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-alibaba-email-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords 🎯",
                        "type": "array",
                        "description": "Add the keywords you want to target on Alibaba (e.g., ['marketing', 'founder', 'business']). 🧠 The actor will search Google for Alibaba profiles/posts matching these keywords and automatically extract email addresses for you. 📧",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform 🌐",
                        "enum": [
                            "Alibaba"
                        ],
                        "type": "string",
                        "description": "Choose the platform you want to scrape. For now this actor focuses on Alibaba for highly targeted B2B leads. 🏬",
                        "default": "Alibaba"
                    },
                    "location": {
                        "title": "Location Filter 📍",
                        "type": "string",
                        "description": "Optional but powerful: narrow down your search by location (e.g., 'London', 'New York', 'Germany'). 🌍 Leave empty to search worldwide and reach a global audience.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter 📧",
                        "type": "array",
                        "description": "Optional: Only keep emails from the domains you care about (e.g., ['@gmail.com', '@outlook.com', '@company.com']). 🎯 Leave empty if you want to collect every valid email we find.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword 🔢",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Set how many emails you want per keyword (default: 20). 📊 Increase for deeper scraping, or lower it for quick, focused batches.",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine ⚙️",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Pick your scraping engine style. 🚀 Cost Effective (New): Blazing‑fast async requests with residential proxies for cheaper, scalable scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors — ultra‑reliable but a bit slower and pricier.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration 🛡️",
                        "type": "object",
                        "description": "Control how your requests are routed. 🌐 By default, no proxy is used. If Google starts blocking or rejecting requests, the actor will automatically retry using datacenter proxies and then residential proxies (up to 3 retries) to keep your scraping running smoothly. 🔄"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```