# Domain Availability, Expiry, WHOIS, DNS, IP, ASN, 70+ TLD (`datascoutapi/domaindaddy`) Actor

Domain availability and expiry dates, WHOIS & RDAP data,  DNS (A, MX, NS, TXT),  IP geolocation and ASN details, calculates domain age, and supports batch processing. Supports 70+ TLDs, handles errors gracefully, and delivers clean, structured JSON output.

- **URL**: https://apify.com/datascoutapi/domaindaddy.md
- **Developed by:** [halam](https://apify.com/datascoutapi) (community)
- **Categories:** Developer tools, SEO tools, MCP servers
- **Stats:** 122 total users, 6 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$10.00/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

## Advanced Domain Intelligence

**Domain Availability, Expiry, Ownership & WHOIS Lookup, DNS Records, SSL Check, Subdomains, IP/ASN & Security Analysis**

**The most comprehensive domain analysis tool on Apify.** Get instant access to WHOIS data, DNS records, SSL certificates, subdomain discovery, and advanced domain intelligence for any website or domain name.

Perfect for SEO professionals, cybersecurity researchers, domain investors, and businesses who need detailed domain information at scale.

---

### 🎯 What Does DomainDaddy Do?

DomainDaddy is your all-in-one domain research assistant that provides:

- **Domain Availability Check** – Instantly detect whether a domain is registered or available.
- **Complete WHOIS Data** – Creation/expiration dates, registrar details, name servers, raw WHOIS, and contact emails.
- **DNS Record Analysis** – A, MX, NS, TXT, SPF, and other essential DNS records.
- **SSL Certificate Check** – HTTPS status, certificate validity, and security details.
- **Subdomain Discovery** – Identify hidden or forgotten subdomains.
- **Domain Age & History** – Exact age in years/days and historical registration insights.
- **IP & ASN Intelligence** – Hosting provider, IP geolocation, ASN number, ASN country, and ASN description.
- **Security & Reputation Scan** – Detect suspicious patterns, blacklist flags, or risk indicators.
- **Batch Domain Analysis** – Process up to 100 domains in a single request.

---

### 🚀 Quick Start Guide

#### Step 1: Prepare Your Input
Create a simple JSON input with the domains you want to analyze:

```json
{
  "domains": ["example.com"]
}
````

#### Step 2: Run the Actor

Execute DomainDaddy on the Apify platform and wait for results.

#### Step 3: Get Comprehensive Results

Receive detailed domain intelligence data in structured JSON format.

***

### 📋 Supported Domain Formats

DomainDaddy automatically handles various input formats:

| Input Format | Example | Notes |
|--------------|---------|-------|
| **Basic Domain** | `example.com` | Standard domain format |
| **With WWW** | `www.example.com` | Automatically normalized |
| **Full URL** | `https://example.com/page` | Extracts domain automatically |
| **Subdomain** | `api.example.com` | Analyzes specific subdomain |
| **Mixed Formats** | Various in same request | Handles all formats together |

***

### 🌍 Supported Top-Level Domains (TLDs)

**70+ TLDs supported including:**

#### Popular TLDs

`.com` `.org` `.net` `.info` `.biz` `.edu` `.gov`

#### Country Code TLDs

`.us` `.uk` `.ca` `.de` `.fr` `.nl` `.au` `.jp` `.cn` `.in` `.it` `.pl` `.se` `.no` `.dk` `.fi` `.be` `.ch` `.at` `.es` `.pt` `.ie` `.il` `.kr` `.tw` `.sg` `.nz` `.za` `.br` `.mx` `.ru` `.ua` `.cz` `.sk` `.hr` `.si` `.ee` `.lv` `.lt` `.kz`

#### Modern TLDs

`.io` `.ai` `.app` `.dev` `.cloud` `.tech` `.online` `.site` `.store` `.shop` `.live` `.space` `.click` `.link` `.fun` `.xyz` `.top` `.pro` `.tv` `.cc` `.me` `.co` `.vip` `.club` `.mobi` `.lol` `.gg` `.one` `.win` `.life`

***

### 💻 Input Configuration

#### Basic Single Domain Analysis

```json
{
  "domains": ["google.com"]
}
```

#### Multiple Domain Batch Processing

```json
{
  "domains": [
    "google.com",
    "github.com", 
    "stackoverflow.com"
  ]
}
```

#### Mixed Format Input (URLs & Domains)

```json
{
  "domains": [
    "example.com",
    "https://www.google.com",
    "http://api.github.com",
    "subdomain.company.org"
  ]
}
```

#### Large Scale Domain Research

```json
{
  "domains": [
    "domain1.com", "domain2.org", "domain3.net",
    "domain4.io", "domain5.ai", "domain6.app"
  ]
}
```

***

### 📊 Complete Output Data Structure

DomainDaddy provides comprehensive domain intelligence in structured JSON format:

#### Core Domain Information

```json
{
  "domain": "example.com",
  "available": false,
  "registrar": "Example Registrar Inc.",
  "registrarCountry": "United States",
  "createdDate": "1995-08-14T04:00:00Z",
  "expiryDate": "2025-08-13T04:00:00Z",
  "updatedDate": "2024-08-14T04:00:00Z"
}
```

#### Domain Age & Timeline

```json
{
  "domainAge": {
    "totalDays": 10572,
    "years": 28,
    "remainingDays": 310,
    "formattedAge": "28 years and 310 days"
  }
}
```

#### DNS & Network Information

```json
{
  "dns": {
    "A": ["93.184.216.34"],
    "MX": [{"exchange": "mail.example.com", "priority": 10}],
    "NS": ["ns1.example.com", "ns2.example.com"],
    "TXT": ["v=spf1 include:_spf.google.com ~all"]
  },
  "ipAddresses": "93.184.216.34",
  "ASN": "15133",
  "ASN_Country": "US",
  "ASN_Description": "EXAMPLE-HOSTING, US"
}
```

#### SSL & Security Analysis

```json
{
  "sslInfo": {
    "hasSSL": true,
    "statusCode": 200,
    "redirected": false,
    "finalUrl": "https://example.com/"
  },
  "reputation": {
    "isBlacklisted": false,
    "sources": []
  }
}
```

#### Subdomain Discovery

```json
{
  "subdomains": [
    "www.example.com",
    "mail.example.com", 
    "api.example.com",
    "blog.example.com"
  ]
}
```

***

### 🎯 Real-World Use Cases

#### 🏢 Business & Marketing

- **Domain Portfolio Management**: Track expiration dates and registrar information for your domain investments
- **Competitor Research**: Analyze competitor domain infrastructure and hosting providers
- **SEO Analysis**: Factor domain age, SSL status, and technical setup into SEO strategies
- **Market Research**: Study domain registration patterns and industry trends

#### 🔒 Security & Compliance

- **Cybersecurity Investigation**: Research suspicious domains and analyze threat indicators
- **Brand Protection**: Monitor for trademark infringement and typosquatting domains
- **Due Diligence**: Verify domain ownership and registration details for business transactions
- **Threat Intelligence**: Map domain infrastructure for security assessments

#### 🛠️ Technical Analysis

- **Infrastructure Mapping**: Discover subdomains and analyze server configurations
- **SSL Certificate Auditing**: Verify HTTPS implementation and security headers
- **Technology Stack Detection**: Identify web servers, frameworks, and hosting providers
- **Domain Quality Assessment**: Evaluate domain structure and reputation metrics

#### 💼 Professional Services

- **Legal Research**: Gather domain ownership evidence for trademark disputes
- **Investment Analysis**: Evaluate domain value based on age, traffic, and technical metrics
- **Acquisition Research**: Perform due diligence on domains before purchase
- **Compliance Monitoring**: Ensure domains meet regulatory and security requirements

***

### ⚡ Performance & Technical Specifications

#### Processing Capabilities

- **Maximum Domains**: Up to 100 domains per request
- **Processing Speed**: 1-2 seconds per domain (with rate limiting)
- **Memory Allocation**: 512MB for optimal performance
- **Timeout Protection**: 5-minute maximum execution time

#### Rate Limiting & Reliability

- **Built-in Delays**: 1-second intervals between domain checks
- **WHOIS Server Respect**: Automatic rate limiting for WHOIS queries
- **DNS Server Protection**: Distributed queries to prevent overload
- **Error Recovery**: Graceful handling of failed lookups with detailed error reporting

#### Expected Processing Times

- **1-5 domains**: 30-60 seconds
- **10-25 domains**: 2-5 minutes
- **50-75 domains**: 8-15 minutes
- **100 domains**: 15-20 minutes

***

### 🔧 Advanced Configuration & Best Practices

#### Optimal Batch Sizes

- **Quick Analysis**: 1-5 domains for immediate results
- **Regular Monitoring**: 10-25 domains for routine checks
- **Bulk Research**: 50-100 domains for comprehensive analysis

#### Input Optimization Tips

1. **Use Clean Domain Names**: Remove unnecessary protocols and paths
2. **Mix Domain Types**: Combine different TLDs for comprehensive research
3. **Validate Input**: Ensure domains are properly formatted before submission
4. **Monitor Logs**: Check execution logs for detailed processing information

#### Error Handling

DomainDaddy provides detailed error information for failed lookups:

```json
{
  "domain": "invalid-domain.xyz",
  "error": "WHOIS lookup failed: Domain not found",
  "errorType": "DOMAIN_NOT_FOUND",
  "timestamp": "2024-01-15T10:30:00.000Z"
}
```

***

### 🆘 Troubleshooting & Support

#### Common Issues & Solutions

**Issue**: Domain validation errors\
**Solution**: Ensure domains are properly formatted (e.g., `example.com` not `http://example.com/`)

**Issue**: WHOIS lookup timeouts\
**Solution**: Reduce batch size or retry with smaller groups of domains

**Issue**: Missing DNS records\
**Solution**: Some domains may not have all record types - this is normal behavior

#### Getting Help

- **Documentation**: Review this README and input examples
- **Logs**: Check actor execution logs for detailed error information
- **Support**: Contact support through the Apify platform console
- **Community**: Join the Apify community for tips and best practices

***

### 📈 Pricing & Usage

DomainDaddy operates on Apify's standard pricing model:

- **Pay per use**: Only pay for actual compute time used
- **Free tier**: Test with small batches using Apify free credits
- **Bulk discounts**: Lower per-domain costs for larger batches
- **Enterprise**: Contact Apify for high-volume pricing

***

### 🔄 Integration & API Access

#### Apify API Integration

```javascript
const client = new ApifyClient({ token: 'your-token' });
const run = await client.actor('your-actor-id').call({
  domains: ['example.com', 'google.com']
});
const results = await client.dataset(run.defaultDatasetId).listItems();
```

#### Webhook Integration

Set up webhooks to automatically process results when analysis completes.

#### Data Export Options

- **JSON**: Structured data for programmatic access
- **CSV**: Spreadsheet-compatible format for analysis
- **Excel**: Direct export to Excel files
- **API**: Real-time access via Apify API

***

### 📄 Legal & Compliance

#### Data Usage Policy

- **Public Information Only**: DomainDaddy only accesses publicly available WHOIS and DNS data
- **Rate Limiting**: Respects server limits and terms of service for all data sources
- **No Personal Data**: Does not collect or store personal information beyond public domain records
- **Compliance**: Follows GDPR, CCPA, and other applicable data protection regulations

#### Terms of Use

This actor is provided under the MIT License for use on the Apify platform. Users are responsible for ensuring their use complies with applicable laws and the terms of service of analyzed domains.

***

### 🚀 Get Started Today

Ready to unlock comprehensive domain intelligence?

1. **[Run DomainDaddy Now](https://console.apify.com/actors)** - Start your first domain analysis
2. **[View Documentation](https://docs.apify.com)** - Learn more about Apify actors
3. **[Join Community](https://discord.gg/jyEM2PRvMU)** - Connect with other users

**Start with our free tier and discover the power of comprehensive domain analysis!**

### 📬 Contact & Support

Have questions, need help, or interested in a private or custom instance?

Reach our team anytime at datascoutapi@gmail.com

# Actor input Schema

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

List of domain names or URLs to check. Supports various formats: domain.com, www.domain.com, https://domain.com, etc. Maximum 100 domains per run.

## `extendedWhois` (type: `boolean`):

Get detailed WHOIS data including registrar info, creation/expiry dates, contact emails, and domain age calculation. Adds ~1-2 seconds per domain.

## `dnsAnalysis` (type: `boolean`):

Analyze MX, NS, TXT records and SPF configuration. Adds ~1 second per domain.

## `networkAnalysis` (type: `boolean`):

Get ASN information, IP geolocation, and network provider details. Adds ~1-2 seconds per domain.

## `securityChecks` (type: `boolean`):

Check DNSSEC status, SSL certificates, and domain reputation. Adds ~1-2 seconds per domain.

## `webAnalysis` (type: `boolean`):

Analyze HTTP responses, server headers, and website status. Adds ~1-2 seconds per domain.

## `subdomainCheck` (type: `boolean`):

Scan for common subdomains (www, mail, ftp, blog, shop, api, cdn, admin). Adds ~1-2 seconds per domain.

## `structureAnalysis` (type: `boolean`):

Analyze domain length, character patterns, and structural properties. Adds minimal time.

## Actor input object example

```json
{
  "domains": [
    "example.com"
  ],
  "extendedWhois": true,
  "dnsAnalysis": true,
  "networkAnalysis": false,
  "securityChecks": false,
  "webAnalysis": false,
  "subdomainCheck": true,
  "structureAnalysis": true
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascoutapi/domaindaddy").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": ["example.com"] }

# Run the Actor and wait for it to finish
run = client.actor("datascoutapi/domaindaddy").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": [
    "example.com"
  ]
}' |
apify call datascoutapi/domaindaddy --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Domain Availability, Expiry, WHOIS, DNS, IP, ASN, 70+ TLD",
        "description": "Domain availability and expiry dates, WHOIS & RDAP data,  DNS (A, MX, NS, TXT),  IP geolocation and ASN details, calculates domain age, and supports batch processing. Supports 70+ TLDs, handles errors gracefully, and delivers clean, structured JSON output.",
        "version": "1.2",
        "x-build-id": "yyMAatqsSWh9BZu56"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datascoutapi~domaindaddy/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datascoutapi-domaindaddy",
                "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/datascoutapi~domaindaddy/runs": {
            "post": {
                "operationId": "runs-sync-datascoutapi-domaindaddy",
                "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/datascoutapi~domaindaddy/run-sync": {
            "post": {
                "operationId": "run-sync-datascoutapi-domaindaddy",
                "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 to check",
                        "minItems": 1,
                        "maxItems": 100,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of domain names or URLs to check. Supports various formats: domain.com, www.domain.com, https://domain.com, etc. Maximum 100 domains per run.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "example.com"
                        ]
                    },
                    "extendedWhois": {
                        "title": "Extended WHOIS Analysis",
                        "type": "boolean",
                        "description": "Get detailed WHOIS data including registrar info, creation/expiry dates, contact emails, and domain age calculation. Adds ~1-2 seconds per domain.",
                        "default": true
                    },
                    "dnsAnalysis": {
                        "title": "DNS Records Analysis",
                        "type": "boolean",
                        "description": "Analyze MX, NS, TXT records and SPF configuration. Adds ~1 second per domain.",
                        "default": true
                    },
                    "networkAnalysis": {
                        "title": "Network & ASN Analysis",
                        "type": "boolean",
                        "description": "Get ASN information, IP geolocation, and network provider details. Adds ~1-2 seconds per domain.",
                        "default": false
                    },
                    "securityChecks": {
                        "title": "Security Analysis",
                        "type": "boolean",
                        "description": "Check DNSSEC status, SSL certificates, and domain reputation. Adds ~1-2 seconds per domain.",
                        "default": false
                    },
                    "webAnalysis": {
                        "title": "Web Server Analysis",
                        "type": "boolean",
                        "description": "Analyze HTTP responses, server headers, and website status. Adds ~1-2 seconds per domain.",
                        "default": false
                    },
                    "subdomainCheck": {
                        "title": "Subdomain Discovery",
                        "type": "boolean",
                        "description": "Scan for common subdomains (www, mail, ftp, blog, shop, api, cdn, admin). Adds ~1-2 seconds per domain.",
                        "default": true
                    },
                    "structureAnalysis": {
                        "title": "Domain Structure Analysis",
                        "type": "boolean",
                        "description": "Analyze domain length, character patterns, and structural properties. Adds minimal time.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```