# Supernet DNS Lookup (`superlativetech/dns-lookup`) Actor

Bulk DNS records lookup. Query MX, SPF, DMARC, DKIM, TXT, CNAME, A, AAAA, NS, SOA and reverse DNS for any domain or IP. Batch thousands or query one instantly using the Standby API. For email reputation scoring, see Supernet Domain Health. For whois, see Supernet Whois.

- **URL**: https://apify.com/superlativetech/dns-lookup.md
- **Developed by:** [Superlative](https://apify.com/superlativetech) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 110 total users, 2 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.07 / 1,000 dns lookups

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Supernet DNS Lookup

Retrieve DNS records for any domain. Supports A, AAAA, MX, CNAME, TXT, NS, SOA, DMARC records and reverse lookups.

### What does Supernet DNS Lookup do?

Supernet DNS Lookup retrieves DNS records for a list of domain names, or performs reverse DNS lookups from IP addresses.

- **All common record types** — A, AAAA, MX, CNAME, TXT, NS, SOA, DMARC
- **Reverse lookups** — Map IP addresses back to hostnames (PTR records)
- **Selective queries** — Choose specific record types or get them all
- **Batch processing** — Query hundreds or thousands of domains at once
- **[Instant API mode](#standby-mode-instant-api)** — Sub-second single-domain lookups via Standby HTTP server

### Use with AI Agents

Available as an MCP tool via the [Apify MCP Server](https://mcp.apify.com).

| Property | Value |
| --- | --- |
| Actor ID | `superlativetech/dns-lookup` |
| Standby URL | `https://superlativetech--dns-lookup.apify.actor` |
| Input | `domains` (string[]) or `domain` (string). Optional: `dnsRecordTypes`, `reverseLookup` |
| Output | `{domain, A[], AAAA[], MX[], TXT[], NS[], SOA[], CNAME[]}` per domain |
| Pricing | $0.10 per 1,000 lookups |
| Idempotent | Yes — same input always produces same output |

#### Output schema
```json
{ "domain": "example.com", "A": [{"value": "93.184.216.34", "ttl": 300}], "MX": [{"priority": 10, "value": "mail.example.com"}] }
````

#### Pipeline composability

Use DNS Lookup for domain intelligence pipelines:

1. **Extract domains** (from URLs/emails) → 2. **DNS Lookup** (this actor) → 3. **Domain Health** (scoring) → 4. **WHOIS** (registration)

#### Standby (instant API)

```
GET https://superlativetech--dns-lookup.apify.actor?token=TOKEN&domain=example.com
GET https://superlativetech--dns-lookup.apify.actor?token=TOKEN&domain=example.com&types=MX,TXT
```

### Why look up DNS records?

DNS records reveal infrastructure details that aren't visible on a website:

- **Email providers** — MX records show if they use Google Workspace, Microsoft 365, or custom mail servers
- **Hosting providers** — A records point to AWS, Cloudflare, or other infrastructure
- **Security posture** — TXT records reveal SPF, DKIM, and DMARC configurations
- **Technology stack** — CNAME records expose CDNs, marketing tools, and services

> **Need domain registration data?** [WHOIS Lookup](https://apify.com/superlativetech/supernet-whois-lookup?fpr=8e9l1) returns registrar, creation and expiry dates, domain age, registrant info, name servers, and DNSSEC status. If you need a full email reputation audit, [Domain Health](https://apify.com/superlativetech/supernet-domain-health?fpr=8e9l1) gives you SPF, DKIM, DMARC validation, blacklist scanning, SSL checks, and a 0-100 score in one call.

#### Use cases

**Technical:**

- DNS auditing and validation
- DNS propagation troubleshooting
- Domain migration checks
- Infrastructure and email provider identification
- IP-to-hostname mapping (PTR)

**Sales & Marketing:**

- Identify email hosting providers for targeted outreach
- Recognize DNS patterns linked to specific technologies
- Analyze competitor DNS infrastructure
- Discover technology stacks used by prospects

### How to use Supernet DNS Lookup

1. Enter your domain names (without `https://` or `www.`)
2. Optionally select specific record types
3. Click **Start** and download your results

#### Standard DNS lookup

Provide domain names to retrieve their DNS records.

```json
{
  "domains": ["example.com", "apify.com"],
  "dnsRecordTypes": ["A", "MX"]
}
```

#### Reverse DNS lookup

Provide IP addresses with `reverseLookup: true` to get hostnames.

```json
{
  "domains": ["8.8.8.8", "1.1.1.1"],
  "reverseLookup": true
}
```

### Standby mode (instant API)

Standby mode keeps a warm container running so you get instant DNS lookups without cold-start delays. Instead of starting a full Actor run, you make a simple HTTP GET request and get results in milliseconds.

This is ideal for:

- **Clay enrichment steps** — single-domain lookups inline
- **Make / n8n HTTP modules** — real-time DNS checks in workflows
- **MCP agents** — AI tools that need instant DNS data

#### Standby URL

```
https://superlativetech--dns-lookup.apify.actor?token=YOUR_API_TOKEN
```

Or use a Bearer token in the `Authorization` header instead of the `token` query parameter.

#### Forward lookup

Look up all record types for a domain:

```bash
curl "https://superlativetech--dns-lookup.apify.actor?token=YOUR_API_TOKEN&domain=apify.com"
```

Look up specific record types:

```bash
curl "https://superlativetech--dns-lookup.apify.actor?token=YOUR_API_TOKEN&domain=google.com&type=MX,TXT"
```

Include DMARC records:

```bash
curl "https://superlativetech--dns-lookup.apify.actor?token=YOUR_API_TOKEN&domain=google.com&type=MX,TXT,DMARC"
```

#### Reverse lookup

Map an IP address back to its hostname:

```bash
curl "https://superlativetech--dns-lookup.apify.actor?token=YOUR_API_TOKEN&ip=8.8.8.8"
```

#### Query parameters

| Parameter | Required | Description |
| --- | --- | --- |
| `domain` | Yes (unless `ip`) | Domain name to look up |
| `ip` | Yes (unless `domain`) | IP address for reverse lookup |
| `type` | No | Comma-separated record types (defaults to all). Valid: A, AAAA, CNAME, MX, TXT, NS, SOA, DMARC |

#### Response format

Success — same shape as batch output:

```json
{
  "domain": "apify.com",
  "dnsRecords": [
    { "type": "A", "ttl": 300, "address": "93.184.216.34" }
  ],
  "status": "Success"
}
```

#### Error responses

| Code | Cause |
| --- | --- |
| 400 | Missing `domain`/`ip`, both provided, invalid domain/IP, invalid record type |
| 405 | Non-GET request |
| 500 | Unexpected server error |

DNS failures (e.g., domain exists but has no MX records) return HTTP 200 with `"status": "No records"` — consistent with batch mode.

### How many domains can you query?

There's no limit. Query as many domains as you need — from a handful to hundreds of thousands. The Actor scales automatically.

For best performance, batch your requests. Processing 1,000 domains at once is more efficient than 10 separate runs of 100 domains each.

### How much will it cost you?

This Actor uses pay-per-result pricing:

| Domains | Cost |
| --- | --- |
| 1,000 | $0.10 |
| 10,000 | $1.00 |
| 100,000 | $10.00 |

Volume discounts apply automatically:

- **Bronze** (100+ items): $0.09/1K
- **Silver** (1,000+ items): $0.08/1K
- **Gold** (10,000+ items): $0.07/1K

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `domains` | array | — | List of domain names or IP addresses to query |
| `dnsRecordTypes` | array | All types | Specific DNS record types to retrieve (ignored for reverse lookups) |
| `reverseLookup` | boolean | `false` | Set to `true` for reverse (PTR) lookups using IP addresses |

#### Available record types

- `A` — IPv4 addresses
- `AAAA` — IPv6 addresses
- `MX` — Mail servers
- `CNAME` — Canonical names (aliases)
- `TXT` — Text records (SPF, DKIM, verification)
- `NS` — Name servers
- `SOA` — Start of authority
- `DMARC` — Email authentication policy (queries `_dmarc` subdomain automatically)

### During the Actor run

The Actor queries DNS servers for each domain in your list. You'll see progress updates as lookups complete.

If you provide invalid input (e.g., an empty list or URLs with protocols), the Actor will stop with an error message.

Results are available in real-time — you can start downloading records before the full run completes.

### Output format

Results are saved to the default dataset. Each domain is a separate item.

#### Standard lookup output

```json
[
  {
    "domain": "example.com",
    "dnsRecords": [
      { "type": "A", "ttl": 300, "address": "93.184.216.34" },
      { "type": "MX", "ttl": 3600, "exchange": "mail.example.com", "priority": 10 }
    ],
    "status": "Success"
  }
]
```

#### Reverse lookup output

```json
[
  {
    "domain": "8.8.8.8",
    "dnsRecords": [
      { "type": "PTR", "hostname": "dns.google" }
    ],
    "status": "Success"
  }
]
```

| Field | Description |
| --- | --- |
| `domain` | The queried domain or IP address |
| `dnsRecords` | Array of DNS records found |
| `status` | "Success" or error message |

### Integrations

Supernet DNS Lookup works with any tool that can call Apify Actors:

- **Clay** — Add as an enrichment step in your Clay tables
- **Make** — Use the Apify module to run the Actor
- **Zapier** — Trigger runs and retrieve results automatically
- **n8n** — Self-hosted workflow automation

You can also use webhooks to trigger actions when a run completes.

### Using Supernet DNS Lookup with the Apify API

The Apify API gives you programmatic access to run Actors, retrieve results, and manage datasets.

**Node.js:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('superlativetech/dns-lookup').call({
  domains: ['apify.com', 'google.com'],
  dnsRecordTypes: ['A', 'MX', 'TXT']
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('superlativetech/dns-lookup').call(run_input={
    'domains': ['apify.com', 'google.com'],
    'dnsRecordTypes': ['A', 'MX', 'TXT']
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Check out the [Apify API reference](https://docs.apify.com/api) for full details, or click the **API** tab above for more code examples.

### Your feedback

We're always improving our Actors. If you have feature requests, find a bug, or need help with a specific use case, please [open an issue](https://console.apify.com/actors/BbYlowTcEOmqzZ6uW/issues) in the Actor's Issues tab.

When Apify asks to share your run data with us, we encourage you to opt in — it's the fastest way for us to spot edge cases and improve results. Sharing is completely optional (you can toggle it anytime under [Account Settings → Privacy](https://console.apify.com/account#/privacy)), and shared runs are automatically deleted by Apify based on your plan's data retention period. We only use shared data to debug issues and improve this Actor.

### Leave a review

If Supernet DNS Lookup helps with your workflows, please [leave a review](https://console.apify.com/actors/BbYlowTcEOmqzZ6uW). Your feedback helps other users discover the tool and helps us understand what's working well.

***

### More from Superlative

**Network Intelligence:**

- **[Supernet Domain Health](https://apify.com/superlativetech/supernet-domain-health?fpr=8e9l1)** — Email reputation audit: SPF, DKIM, DMARC, blacklists, SSL, and 0-100 scoring
- **[Supernet WHOIS Lookup](https://apify.com/superlativetech/supernet-whois-lookup?fpr=8e9l1)** — Domain registration data: registrar, dates, domain age, registrant, name servers
- **[HTTP API](https://apify.com/superlativetech/http-api?fpr=8e9l1)** — General-purpose HTTP request utility

**Data Cleaning:**

- **[Superclean Company Names](https://apify.com/superlativetech/superclean-company-names?fpr=8e9l1)** — Normalize company names for CRM and outreach
- **[Superclean Job Titles](https://apify.com/superlativetech/superclean-job-titles?fpr=8e9l1)** — Standardize job titles for lead scoring
- **[Superclean Person Names](https://apify.com/superlativetech/superclean-person-names?fpr=8e9l1)** — Clean and format person names
- **[Superclean Product Names](https://apify.com/superlativetech/superclean-product-names?fpr=8e9l1)** — Normalize product and brand names
- **[Superclean Places](https://apify.com/superlativetech/superclean-places?fpr=8e9l1)** — Parse and standardize location strings
- **[Superclean URLs](https://apify.com/superlativetech/superclean-urls?fpr=8e9l1)** — Clean and normalize URLs
- **[Superclean Phone Numbers](https://apify.com/superlativetech/superclean-phone-numbers?fpr=8e9l1)** — Format and validate phone numbers

**Lead Intelligence:**

- **[Superlead ICP Scorer](https://apify.com/superlativetech/superlead-icp-scorer?fpr=8e9l1)** — Score leads against your Ideal Customer Profile with AI

Built by Superlative

# Actor input Schema

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

Domain names (without protocol prefixes like https://) for standard DNS lookup or IP addresses for reverse DNS lookup.

## `dnsRecordTypes` (type: `array`):

Specific DNS record types to retrieve (e.g., A, MX, TXT). Ignored for reverse DNS lookups.

## `reverseLookup` (type: `boolean`):

Set to true to perform reverse DNS lookups (IP to hostname). Domains array must contain valid IP addresses if enabled.

## Actor input object example

```json
{
  "domains": [
    "apify.com"
  ],
  "dnsRecordTypes": [
    "A",
    "AAAA",
    "MX",
    "TXT",
    "NS",
    "SOA",
    "CNAME"
  ],
  "reverseLookup": false
}
```

# Actor output Schema

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

No description

# 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": [
        "apify.com"
    ],
    "dnsRecordTypes": [
        "A",
        "AAAA",
        "MX",
        "TXT",
        "NS",
        "SOA",
        "CNAME"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("superlativetech/dns-lookup").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": ["apify.com"],
    "dnsRecordTypes": [
        "A",
        "AAAA",
        "MX",
        "TXT",
        "NS",
        "SOA",
        "CNAME",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("superlativetech/dns-lookup").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": [
    "apify.com"
  ],
  "dnsRecordTypes": [
    "A",
    "AAAA",
    "MX",
    "TXT",
    "NS",
    "SOA",
    "CNAME"
  ]
}' |
apify call superlativetech/dns-lookup --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Supernet DNS Lookup",
        "description": "Bulk DNS records lookup. Query MX, SPF, DMARC, DKIM, TXT, CNAME, A, AAAA, NS, SOA and reverse DNS for any domain or IP. Batch thousands or query one instantly using the Standby API. For email reputation scoring, see Supernet Domain Health. For whois, see Supernet Whois.",
        "version": "1.2",
        "x-build-id": "9EQxnAbGrl2Bih6fI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/superlativetech~dns-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-superlativetech-dns-lookup",
                "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/superlativetech~dns-lookup/runs": {
            "post": {
                "operationId": "runs-sync-superlativetech-dns-lookup",
                "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/superlativetech~dns-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-superlativetech-dns-lookup",
                "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 IP addresses",
                        "type": "array",
                        "description": "Domain names (without protocol prefixes like https://) for standard DNS lookup or IP addresses for reverse DNS lookup.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dnsRecordTypes": {
                        "title": "DNS Record Types",
                        "type": "array",
                        "description": "Specific DNS record types to retrieve (e.g., A, MX, TXT). Ignored for reverse DNS lookups.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "reverseLookup": {
                        "title": "Reverse DNS Lookup",
                        "type": "boolean",
                        "description": "Set to true to perform reverse DNS lookups (IP to hostname). Domains array must contain valid IP addresses if enabled.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```