# Website Email Phone Finder (`api-empire/website-email-phone-finder`) Actor

A powerful website email and phone number finder designed to extract verified contact details from any website in seconds. This tool crawls multiple pages including contact

- **URL**: https://apify.com/api-empire/website-email-phone-finder.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** AI, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.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

### **Social Media** Email Scraper 📱

Website Email & Phone Finder can **extract** a wide range of **contact** information from social media platforms. It enables users to gather crucial details such as email addresses, phone numbers, and profile links.

This **data** is essential for outreach, networking, and building business relationships. The tool also retrieves additional information like usernames, follower counts, and bio descriptions.

By automating the process, it ensures efficiency and accuracy in **data** collection. Users can quickly access verified **contact** details, reducing the time spent on manual searches.

This makes it an invaluable tool for professionals seeking to enhance their **contact** **data**base.

Website Email & Phone Finder is a powerful tool designed to extract contact information from social media platforms efficiently. It helps users find email addresses and phone numbers associated with profiles and pages online.

This tool simplifies the process of discovering business contact details, making it ideal for networking, outreach, and lead generation. By automating the search for contact information, it saves time and effort for professionals.

With its advanced scraping capabilities, Website Email & Phone Finder ensures accurate and reliable results. It is suitable for individuals and businesses looking to expand their contact database.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.apiempire@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Address | Extracts email addresses associated with social media profiles and pages. |
| Phone Number | Retrieves phone numbers listed on profiles or public pages. |
| Profile URL | Captures the URLs of social media profiles for easy access. |
| Username | Finds usernames linked to the profiles. |
| Follower Count | Extracts the number of followers a profile or page has. |
| Bio Description | Retrieves the bio or description text from profiles. |
| Business Details | Collects business-related information such as company names or addresses. |
| Website Links | Extracts links to external websites listed on profiles. |

### Key Features of **Social Media** Email Scraper

Here are the **standout features** that make the **Social Media** Email Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ Efficiently extracts email addresses and phone numbers from social media platforms
- ⭐ Supports multiple social media platforms for comprehensive data collection
- ⭐ Offers accurate and reliable contact information for professional use
- ⭐ Automates the process of finding business contact details online
- ⭐ User-friendly interface requiring no technical expertise to operate
- ⭐ Provides additional data such as usernames bio descriptions and follower counts
- ⭐ Ensures compliance with legal and ethical guidelines for data scraping
- ⭐ Delivers results in a structured format for easy analysis and usage
- ⭐ **Customizable** scraping options to meet specific user requirements
- ⭐ **Secure** and confidential data handling to protect user information
- ⭐ **Regular** updates to support new platform features and changes
- ⭐ Scalable solution for both small-scale and large-scale data extraction needs

### How to use **Social Media** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Social Media** emails today:

1. ✅ **Sign up** or **log in** to access the Website Email  Phone Finder tool
2. ✅ **Select** the social media platform you wish to scrape contact details from
3. ✅ Enter the profile URL or search query to target specific profiles or pages
4. ✅ Customize the scraping options to specify the data you want to extract
5. ✅ **Start** the scraping process and wait for the tool to gather the data
6. ✅ **Review** the extracted contact information displayed in the results section
7. ✅ Download the data in your preferred format for further use
8. ✅ Use the contact details responsibly and in compliance with legal guidelines

### Use Cases 🎯

Lead Generation
🎯 **Find** contact details of potential clients or partners
🎯 Build a database of business contacts for marketing campaigns

Recruitment
🎯 Discover contact information of potential job candidates
🎯 Reach out to professionals in specific industries or roles

Networking
🎯 Connect with influencers and thought leaders in your field
🎯 Expand your professional network by finding contact details online

Market Research
🎯 **Analyze** competitor profiles and their contact strategies
🎯 Gather data for insights into industry trends and practices

Sales Outreach
🎯 **Identify** and contact decision-makers in target companies
🎯 Streamline outreach efforts with accurate contact information

### Why choose us? 💎

Website Email & Phone Finder stands out as a **reliable** and efficient contact information lookup tool. It offers **advanced** scraping capabilities to find email addresses, phone numbers, and other contact details online.

The tool is designed to be **user-friendly**, making it accessible to professionals without technical expertise. With support for multiple social media platforms, it provides a comprehensive solution for discovering business contact info.

Users can customize their scraping options to meet specific needs, ensuring they get the most relevant data. The tool is built with security and privacy in mind, ensuring confidential handling of user information.

Regular updates keep the tool compatible with platform changes, maintaining its effectiveness over time. Whether you're a marketer, recruiter, or sales professional, Website Email & Phone Finder is the perfect tool to enhance your contact database and streamline your outreach efforts.

### **Social Media** Email Scraper Scalability 📈

Website Email & Phone Finder is designed to handle both small-scale and **large-scale** data extraction needs. Whether you're an individual looking for a few contact details or a business needing **extensive** data, the tool can adapt to your requirements.

Its **advanced** algorithms ensure fast and **efficient** scraping, even for large datasets. Users can process multiple profiles or pages simultaneously, saving time and effort.

The tool's **customizable** options allow for targeted data extraction, ensuring you get only the information you need. With its scalable infrastructure, Website Email & Phone Finder can support growing businesses and evolving data needs.

It is a reliable solution for professionals and organizations seeking to expand their contact database **efficient**ly.

### **Social Media** Email Scraper Legal Guidelines ⚖️

**Yes**—scraping **Social Media** is **legal** as long as you follow **ethical** and **compliant** practices. The **Social Media** Email Scraper extracts only **publicly available** information from **public** **Social Media** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with the terms of service of the social media platforms being scraped
⚖️ **Use** the tool only for lawful purposes such as business networking or outreach
⚖️ **Avoid** scraping personal information without proper consent from the individuals
⚖️ **Do not** use the extracted data for spamming or unsolicited communications
⚖️ Respect privacy laws and regulations applicable in your region or industry
⚖️ **Use** the tool responsibly and ethically to maintain professional integrity
⚖️ Verify the accuracy of the extracted data before using it for any purpose
⚖️ Always disclose your identity and intent when contacting individuals using the extracted data

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Website Email & Phone Finder"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Social Media",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails to collect (default 20) |
| platform | Platform to scrape (Social Media) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Social Media",
    "keyword": "Website Email & Phone Finder",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "email": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Social Media as the source |
| keyword | Keyword that triggered the result (Website Email & Phone Finder) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Social Media profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Website Email & Phone Finder?

Website Email & Phone Finder is a tool designed to extract email addresses, phone numbers, and other contact details from social media platforms.

#### Which platforms does the tool support?

The tool supports multiple social media platforms for comprehensive data extraction.

#### Is the tool user-friendly?

**Yes**, the tool is designed to be easy to use, even for individuals without technical expertise.

#### Can I customize the data I want to **extract**?

**Yes**, the tool allows users to customize scraping options to target specific data types.

#### Is the **extract**ed data accurate?

The tool ensures accurate and reliable data extraction for professional use.

#### Can I use the tool for **lead generation**?

**Yes**, the tool is ideal for finding contact details for lead generation and outreach.

#### Is the tool compliant with **legal** guidelines?

**Yes**, the tool is designed to comply with legal and ethical guidelines for data scraping.

#### How do I download the **extract**ed data?

You can download the extracted data in your preferred format directly from the tool.

#### Is my data **secure** while using the tool?

**Yes**, the tool ensures **secure** and confidential handling of user information.

#### Does the tool support **large-scale** data **extract**ion?

**Yes**, the tool is scalable and can handle both small-scale and large-scale data extraction needs.

#### Can I use the tool for market research?

**Yes**, the tool is suitable for gathering data for market research and competitor analysis.

#### Are there any restrictions on scraping personal information?

**Yes**, users must comply with privacy laws and obtain proper consent before scraping personal information.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with platform changes and new features.

#### Can I scrape multiple profiles at once?

**Yes**, the tool supports simultaneous processing of multiple profiles or pages.

#### What formats are available for data **export**?

The tool allows users to export data in various formats, such as **CSV** or Excel files.

# Actor input Schema

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

List of keywords to search for on Multi-Platform (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Multi-Platform profiles/posts containing these keywords and extract email addresses.

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

Select platform.

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

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

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

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

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

Maximum number of emails to collect per keyword (default: 20).

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

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Instagram",
  "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("api-empire/website-email-phone-finder").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("api-empire/website-email-phone-finder").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 api-empire/website-email-phone-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=api-empire/website-email-phone-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Email Phone Finder",
        "description": "A powerful website email and phone number finder designed to extract verified contact details from any website in seconds. This tool crawls multiple pages including contact",
        "version": "0.1",
        "x-build-id": "V65TojFNnC3AXV2as"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~website-email-phone-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-website-email-phone-finder",
                "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/api-empire~website-email-phone-finder/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-website-email-phone-finder",
                "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/api-empire~website-email-phone-finder/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-website-email-phone-finder",
                "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": "List of keywords to search for on Multi-Platform (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Multi-Platform profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Instagram",
                            "Linkedin",
                            "Tiktok",
                            "Youtube",
                            "Google-Maps",
                            "Airbnb",
                            "Reddit",
                            "Twitter",
                            "Spotify",
                            "Skool",
                            "Booking",
                            "Facebook",
                            "Yellowpages",
                            "Etsy",
                            "Eventbrite",
                            "Zillow",
                            "Craigslist",
                            "Agoda",
                            "Linktr",
                            "Twitch",
                            "Amazon",
                            "Telegram",
                            "Ubereats",
                            "Trivago",
                            "Kayak",
                            "Redbubble",
                            "Audible",
                            "Discord",
                            "Substack",
                            "Crunchbase",
                            "Doordash",
                            "Yelp",
                            "Pinterest",
                            "Threads",
                            "Soundcloud",
                            "Tripadvisor",
                            "Hotels",
                            "Swiggy",
                            "Dailymotion",
                            "Luma",
                            "Bandcamp",
                            "Shopee",
                            "Google-Play",
                            "Expedia",
                            "Trulia",
                            "Realtor",
                            "Quora",
                            "Tumblr",
                            "Gumroad",
                            "Steampowered",
                            "Redfin",
                            "Tokopedia",
                            "Vimeo",
                            "Wayfair",
                            "Overstock",
                            "Apple-Apps",
                            "Aliexpress",
                            "Snapchat",
                            "Alibaba",
                            "Blueskyweb",
                            "Mercadolibre",
                            "Patreon",
                            "Goodreads",
                            "Walmart",
                            "Douyin",
                            "Taobao",
                            "Trip",
                            "Vk",
                            "Co-Rakuten",
                            "Chewy",
                            "Target",
                            "Lazada",
                            "Skyscanner",
                            "Zomato",
                            "Instacart",
                            "Newegg",
                            "Flipkart",
                            "Trendyol",
                            "Allegro",
                            "Kickstarter"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Instagram"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
