# Website Phone Number Finder ✅ $2/1k (`x_guru/website-phone-number-finder`) Actor

From $2.00 / 1,000 saved phone results. Fast website phone number finder for public business phone numbers, tel links, social profiles, source URLs, and contact-page diagnostics from domains.

- **URL**: https://apify.com/x\_guru/website-phone-number-finder.md
- **Developed by:** [Hundevmode Labs](https://apify.com/x_guru) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 saved website phone results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Website Phone Number Finder: Scrape Phone Numbers from Websites

From **$2.00 / 1,000 saved phone results** on paid Apify plans. Use this **website phone number finder** and **business phone number scraper** to scan domains or website URLs and extract public phone numbers, `tel:` links, social profiles, source URLs, and crawl diagnostics.

This actor is built for fast **domain phone number scraping**. Paste a list of websites, run a shallow browserless crawl, and get one clean result per website where at least one public phone number is found. It checks the homepage or supplied URL, follows likely contact/about/legal/team pages, and saves phone-first lead records by default.

Use it when you already have domains from Google Maps, CRMs, spreadsheets, directories, search results, company databases, or lead lists and need public phone contacts from each website.

### AI agent skill

Use the dedicated [Website Phone Number Finder Apify agent skill](https://github.com/hundevmode/apify-website-phone-number-finder-agent-skill) when you want AI agents to normalize domain lists, run this actor through Apify, control spend with `maxTotalChargeUsd`, and return public website phone rows for outreach, CRM, Sheets, n8n, BI, or enrichment workflows.

Install with skills.sh-compatible agents:

```bash
npx skills add hundevmode/apify-website-phone-number-finder-agent-skill \
  --skill website-phone-number-finder-apify
````

ClawHub skill slug: `website-phone-number-finder-apify`.

### At a glance

| Need | Use this actor for |
| --- | --- |
| Website phone scraping | Find public phone numbers from company websites |
| Domain phone number finder | Turn domains and URLs into structured phone lead records |
| Business phone scraper | Extract visible phone numbers and `tel:` links from contact pages |
| Lead generation | Enrich existing website lists with phone-ready outreach data |
| Sales enrichment | Add phones, source URLs, and social profiles to domain lists |
| CRM cleanup | Convert raw domains into normalized phone contact records |
| Agency prospecting | Scan niche website lists collected from Google Maps, directories, or search results |
| Bulk export | Download phone results as JSON, CSV, Excel, or through the Apify API |

### Quick start

Start with a list of domains. The actor accepts bare domains and full URLs in the same input field.

```json
{
  "domains": [
    "alchemist.dk",
    "disfrutarbarcelona.com",
    "diverxo.com"
  ],
  "maxResults": 1000,
  "resultMode": "phonesOnly",
  "maxPagesPerWebsite": 3,
  "concurrency": 100,
  "extractPhones": true,
  "extractEmails": false,
  "extractSocials": true,
  "includePersonalData": true
}
```

### Pricing

The actor uses Apify pay-per-event pricing. The primary event is `website-phone-saved`, charged only when a website phone result is saved to the dataset.

| Event | Free | Paid plans |
| --- | --- | --- |
| Saved website phone result | $5.00 / 1,000 saved phone results | $2.00 / 1,000 saved phone results |
| Actor start | $0.00005 per start event | $0.00001 per start event |

Scanned websites that do not match the selected result mode are not charged as saved phone results. The actor respects Apify `maxTotalChargeUsd` and stops before saving more paid results than the run budget allows.

### What it extracts

| Data group | Example fields |
| --- | --- |
| Website identity | `input`, `url`, `domain`, `status` |
| Phone numbers | `phones`, `phoneDetails.phone`, `phoneDetails.sourceUrl` |
| Optional emails | `emails`, `emailDetails.email`, `emailDetails.type`, `emailDetails.sourceUrl`, `emailDetails.domainMatch` |
| Social links | `facebooks`, `instagrams`, `linkedIns`, `twitters`, `youtubes`, `tiktoks`, `socialLinks` |
| Crawl diagnostics | `pagesFetched`, `fetchedUrls`, `httpStatusCodes`, `errors`, `durationMs` |
| Contact counts | `contactSignals.phones`, `contactSignals.emails`, `contactSignals.socialProfiles`, `contactSignals.pagesFetched` |

Phone numbers are normalized to an international-style format when possible. For example, many US 10-digit numbers are returned as `+1...`, while international `+` numbers keep their country code.

### Input options

#### Domains or URLs

Use `domains` for domains and URLs. Both formats are accepted:

```json
{
  "domains": [
    "example.com",
    "https://example.com/contact"
  ]
}
```

The actor tries HTTPS, WWW, and HTTP variants when needed. For bulk phone scraping, paste one domain per row. For exact-page extraction, paste full URLs such as contact pages, locations pages, booking pages, or company profile pages.

#### Result mode

| Mode | Saved dataset items |
| --- | --- |
| `phonesOnly` | Only websites where at least one public phone number was found. This is the default. |
| `contactsOnly` | Websites with at least one phone, optional email, or social profile. |
| `allWebsites` | All scanned websites, including websites where no phone number was found. |

#### Crawl depth and speed

| Field | What it does |
| --- | --- |
| `maxPagesPerWebsite` | Number of pages to fetch per website. Default is 3. |
| `concurrency` | Number of websites scanned in parallel. Default is 100. |
| `requestTimeoutSecs` | Per-page timeout. Default is 5 seconds. |
| `sameDomainOnly` | Follow only same-domain contact/about links. Social links are still extracted. |

The actor prioritizes URLs containing contact, about, team, staff, impressum, imprint, legal, privacy, reservation, booking, and similar contact-page hints.

#### Contact fields

| Field | What it does |
| --- | --- |
| `extractPhones` | Extract phone numbers from visible text and `tel:` links. Keep this enabled for phone scraping. |
| `extractEmails` | Optionally include public emails as secondary fields. Disabled by default. |
| `extractSocials` | Extract public social media profile links. |
| `includePersonalData` | Include personal LinkedIn URLs and person-like emails when optional email extraction is enabled. |

### How it works

1. Normalizes every domain or URL.
2. Tries HTTPS, WWW, and HTTP variants when needed.
3. Downloads HTML with a Chrome-like HTTP client optimized for high concurrency.
4. Extracts phone numbers from visible text and `tel:` links.
5. Scores internal links and follows the best contact/about/legal/team pages.
6. Optionally extracts emails and social profile links.
7. Applies `resultMode`.
8. Saves one dataset item per matching website using the PPE result event.
9. Writes `RUN_SUMMARY` with processed count, saved count, filters, and budget guard details.

The default path is HTTP-first and browserless for speed. It uses a Chrome-like HTTP client with high concurrency, so large domain lists can run faster than browser-first website contact scrapers.

### Output example

```json
{
  "input": "alchemist.dk",
  "url": "https://alchemist.dk/",
  "domain": "alchemist.dk",
  "status": "found",
  "phones": ["+4531716161"],
  "phoneDetails": [
    {
      "phone": "+4531716161",
      "sourceUrl": "https://alchemist.dk/"
    }
  ],
  "emails": [],
  "emailDetails": [],
  "facebooks": [],
  "instagrams": ["https://www.instagram.com/restaurantalchemist/"],
  "linkedIns": [],
  "contactSignals": {
    "emails": 0,
    "phones": 1,
    "socialProfiles": 1,
    "pagesFetched": 3
  },
  "pagesFetched": 3,
  "fetchedUrls": [
    "https://alchemist.dk/",
    "https://alchemist.dk/contact",
    "https://alchemist.dk/about"
  ],
  "durationMs": 1240
}
```

### Run summary

Every run writes `RUN_SUMMARY` to the default key-value store.

Useful fields:

| Field | Meaning |
| --- | --- |
| `inputWebsites` | Number of submitted websites |
| `processed` | Number of websites scanned |
| `saved` | Number of saved dataset items |
| `filteredOut` | Websites scanned but not saved due to result mode |
| `failed` | Websites that could not be fetched |
| `chargeLimitReached` | Whether Apify PPE budget stopped the run |
| `budget.remainingItems` | PPE budget guard estimate before saving |
| `exhaustionReason` | `target_reached`, `input_exhausted`, or `charge_limit_reached` |

Per-website errors are stored in the item and run summary. The actor is designed to finish successfully and report failed websites in `RUN_SUMMARY` instead of failing the whole run because one domain is slow, invalid, or blocked.

### API usage

```bash
curl -X POST "https://api.apify.com/v2/acts/x_guru~website-phone-number-finder/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "domains": ["alchemist.dk", "disfrutarbarcelona.com"],
    "resultMode": "phonesOnly",
    "maxPagesPerWebsite": 3,
    "concurrency": 100,
    "extractPhones": true,
    "extractEmails": false,
    "extractSocials": true
  }'
```

### Tips

- Use `phonesOnly` for paid phone lead extraction and website phone scraping.
- Use `contactsOnly` if social profiles or optional emails are useful even when no phone number is found.
- Increase `maxPagesPerWebsite` to 5-10 for sites where phones are hidden on locations, booking, contact, legal, or imprint pages.
- Keep `requestTimeoutSecs` low for large batches so slow websites do not block throughput.
- Set an Apify maximum cost per run when processing very large domain lists.
- Paste full contact-page URLs when you already know the exact page that contains phone numbers.

### Common searches this actor covers

- website phone number finder
- website phone scraper
- domain phone number finder
- business phone number scraper
- company phone finder
- phone number scraper
- phone scraper for lead generation
- website contact phone extractor

# Actor input Schema

## `domains` (type: `array`):

Domains or full website URLs to scan for public phone numbers. You can paste domains such as example.com or URLs such as https://example.com/contact.

## `maxResults` (type: `integer`):

Maximum number of saved website phone results. In Phones only mode, websites without phone numbers are scanned but not saved.

## `resultMode` (type: `string`):

Choose what should be saved to the dataset.

## `maxPagesPerWebsite` (type: `integer`):

How many pages to fetch from each website. The actor starts with the homepage or supplied URL, then follows likely contact/about/legal/team pages.

## `concurrency` (type: `integer`):

How many websites to scan in parallel. Increase for large lists; decrease if many websites throttle requests.

## `requestTimeoutSecs` (type: `integer`):

Per-page timeout. Short timeouts keep large batches moving quickly.

## `extractPhones` (type: `boolean`):

Extract public phone numbers from visible page text and tel: links.

## `extractEmails` (type: `boolean`):

Optionally include public emails as secondary enrichment fields. Phone numbers remain the default save condition.

## `extractSocials` (type: `boolean`):

Extract public Facebook, Instagram, LinkedIn, X/Twitter, YouTube, and TikTok profile links.

## `includePersonalData` (type: `boolean`):

Enable personal LinkedIn profile URLs and person-like emails when optional email extraction is enabled. Disable to keep mostly company-level contacts.

## `sameDomainOnly` (type: `boolean`):

Only follow contact/about links on the same root domain. Social profile links are still extracted.

## Actor input object example

```json
{
  "domains": [
    "alchemist.dk",
    "disfrutarbarcelona.com",
    "diverxo.com"
  ],
  "maxResults": 1000,
  "resultMode": "phonesOnly",
  "maxPagesPerWebsite": 3,
  "concurrency": 100,
  "requestTimeoutSecs": 5,
  "extractPhones": true,
  "extractEmails": false,
  "extractSocials": true,
  "includePersonalData": true,
  "sameDomainOnly": true
}
```

# Actor output Schema

## `results` (type: `string`):

Website phone results saved to the default dataset.

## `summary` (type: `string`):

Run-level diagnostics, including processed websites, saved phone results, filters, and PPE budget details.

# 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 = {
    "domains": [
        "alchemist.dk",
        "disfrutarbarcelona.com",
        "diverxo.com"
    ],
    "maxResults": 1000,
    "resultMode": "phonesOnly",
    "maxPagesPerWebsite": 3,
    "concurrency": 100,
    "requestTimeoutSecs": 5,
    "extractPhones": true,
    "extractEmails": false,
    "extractSocials": true,
    "includePersonalData": true,
    "sameDomainOnly": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("x_guru/website-phone-number-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 = {
    "domains": [
        "alchemist.dk",
        "disfrutarbarcelona.com",
        "diverxo.com",
    ],
    "maxResults": 1000,
    "resultMode": "phonesOnly",
    "maxPagesPerWebsite": 3,
    "concurrency": 100,
    "requestTimeoutSecs": 5,
    "extractPhones": True,
    "extractEmails": False,
    "extractSocials": True,
    "includePersonalData": True,
    "sameDomainOnly": True,
}

# Run the Actor and wait for it to finish
run = client.actor("x_guru/website-phone-number-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 '{
  "domains": [
    "alchemist.dk",
    "disfrutarbarcelona.com",
    "diverxo.com"
  ],
  "maxResults": 1000,
  "resultMode": "phonesOnly",
  "maxPagesPerWebsite": 3,
  "concurrency": 100,
  "requestTimeoutSecs": 5,
  "extractPhones": true,
  "extractEmails": false,
  "extractSocials": true,
  "includePersonalData": true,
  "sameDomainOnly": true
}' |
apify call x_guru/website-phone-number-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Phone Number Finder ✅ $2/1k",
        "description": "From $2.00 / 1,000 saved phone results. Fast website phone number finder for public business phone numbers, tel links, social profiles, source URLs, and contact-page diagnostics from domains.",
        "version": "0.1",
        "x-build-id": "aOWMpe53ViOApVAF7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/x_guru~website-phone-number-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-x_guru-website-phone-number-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/x_guru~website-phone-number-finder/runs": {
            "post": {
                "operationId": "runs-sync-x_guru-website-phone-number-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/x_guru~website-phone-number-finder/run-sync": {
            "post": {
                "operationId": "run-sync-x_guru-website-phone-number-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": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "🌐 Domains or website URLs",
                        "type": "array",
                        "description": "Domains or full website URLs to scan for public phone numbers. You can paste domains such as example.com or URLs such as https://example.com/contact.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "alchemist.dk",
                            "disfrutarbarcelona.com",
                            "diverxo.com"
                        ]
                    },
                    "maxResults": {
                        "title": "Maximum saved phone results",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum number of saved website phone results. In Phones only mode, websites without phone numbers are scanned but not saved.",
                        "default": 1000
                    },
                    "resultMode": {
                        "title": "Result mode",
                        "enum": [
                            "phonesOnly",
                            "contactsOnly",
                            "allWebsites"
                        ],
                        "type": "string",
                        "description": "Choose what should be saved to the dataset.",
                        "default": "phonesOnly"
                    },
                    "maxPagesPerWebsite": {
                        "title": "Pages to check per website",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "How many pages to fetch from each website. The actor starts with the homepage or supplied URL, then follows likely contact/about/legal/team pages.",
                        "default": 3
                    },
                    "concurrency": {
                        "title": "Parallel websites",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many websites to scan in parallel. Increase for large lists; decrease if many websites throttle requests.",
                        "default": 100
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 2,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Per-page timeout. Short timeouts keep large batches moving quickly.",
                        "default": 5
                    },
                    "extractPhones": {
                        "title": "Extract phone numbers",
                        "type": "boolean",
                        "description": "Extract public phone numbers from visible page text and tel: links.",
                        "default": true
                    },
                    "extractEmails": {
                        "title": "Also extract emails",
                        "type": "boolean",
                        "description": "Optionally include public emails as secondary enrichment fields. Phone numbers remain the default save condition.",
                        "default": false
                    },
                    "extractSocials": {
                        "title": "Extract social profiles",
                        "type": "boolean",
                        "description": "Extract public Facebook, Instagram, LinkedIn, X/Twitter, YouTube, and TikTok profile links.",
                        "default": true
                    },
                    "includePersonalData": {
                        "title": "Personal data",
                        "type": "boolean",
                        "description": "Enable personal LinkedIn profile URLs and person-like emails when optional email extraction is enabled. Disable to keep mostly company-level contacts.",
                        "default": true
                    },
                    "sameDomainOnly": {
                        "title": "Same-domain crawl only",
                        "type": "boolean",
                        "description": "Only follow contact/about links on the same root domain. Social profile links are still extracted.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
