# Ubersuggest Scraper (`maximedupre/ubersuggest-scraper`) Actor

Scrape Ubersuggest SEO data from domains, URLs, and keywords. Export domain overviews, top pages, backlinks, and keyword suggestions without Ubersuggest cookies.

- **URL**: https://apify.com/maximedupre/ubersuggest-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.50 / 1,000 ubersuggest seo items

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

### 🔎 Ubersuggest scraper for SEO research

Ubersuggest Scraper collects SEO data from [Ubersuggest](https://app.neilpatel.com/en/ubersuggest/overview) for domains, URLs, and keyword seeds. Add a website such as `apify.com` or a keyword such as `automation`, and the Actor saves analysis-ready rows for domain overview metrics, top pages, backlink summaries, backlinks, and keyword suggestions.

Use this Ubersuggest scraper when you need quick SEO inputs for competitor research, content planning, backlink checks, keyword expansion, spreadsheet analysis, or recurring market monitoring. The output is structured for Apify dataset exports, schedules, webhooks, integrations, and API workflows.

No Ubersuggest login, cookies, API key, or paid Ubersuggest account is required from you. For a small first run, keep the prefilled domains and defaults to collect domain overview, top page, backlink overview, and backlink rows. Add a keyword seed only when you want keyword suggestions.

### ✅ What this Actor does

- Accepts domains such as `example.com`, full URLs such as `https://example.com/blog`, and keyword seeds.
- Returns domain overview rows with authority, backlinks, organic traffic, paid traffic, ranking buckets, traffic history, and country traffic.
- Returns top page rows with page URLs, titles, traffic, backlinks, referring domains, social shares, and rank.
- Returns backlink overview rows with domain authority, referring domains, backlinks, follow/nofollow counts, and government or education referring-domain counts when available.
- Can return individual backlink rows with source URL, target URL, anchor, title, authority, spam score, discovery dates, nofollow status, and rank.
- Returns keyword suggestion rows with search volume, CPC, competition, SEO difficulty, paid difficulty, search intent, freshness date, and rank.
- Lets you choose which result types to save and set per-domain or per-keyword limits.

The Actor is focused on public Ubersuggest SEO data. It does not scrape private projects, logged-in dashboards, rank tracking campaigns, site audit reports, or data that requires your own Ubersuggest account.

### 📦 Data you can extract

Each dataset item is one Ubersuggest SEO item. The `rowType` field tells you which kind of item was saved:

- `domain_overview` - domain authority, backlinks, referring domains, organic and paid traffic metrics, keyword ranking buckets, traffic history, and top country traffic.
- `top_page` - a ranked page URL from the submitted domain with title, estimated traffic, backlinks, referring domains, and social-share counts.
- `backlinks_overview` - summary backlink metrics for the submitted domain.
- `backlink` - one backlink source with the linked URL, anchor text, authority metrics, spam score, dates, and nofollow status.
- `keyword_suggestion` - one keyword idea with volume, CPC, competition, SEO difficulty, paid difficulty, search intent, and rank.

Every row also includes `target`, `normalizedDomain`, `keyword`, `country`, `language`, `sourceName`, `sourceUrl`, and `scrapedAt` so you can trace where each item came from.

### 🚀 How to run it

1. Add one or more values in `Domains or URLs` and/or `Keyword seeds`.
2. Keep `Country` as `us` and `Language` as `en`, or switch them to the locale you want Ubersuggest to use.
3. Choose the result types you need. For keyword research only, you can leave domains empty and keep keyword suggestions enabled.
4. Keep the default limits for a small first run, then increase them once the output shape looks right.
5. Run the Actor and open the dataset.

For domain research, start with the prefilled domains and default limits. For keyword research, add one seed and enable keyword suggestions. That keeps the first run small while still showing the output format.

### ⚙️ Input options

```json
{
	"domainsOrUrls": ["apify.com", "shopify.com"],
	"keywords": [],
	"country": "us",
	"language": "en",
	"includeOverview": true,
	"includeTopPages": true,
	"includeBacklinksOverview": true,
	"includeBacklinks": true,
	"includeKeywordSuggestions": false,
	"maxTopPages": 10,
	"maxBacklinks": 25,
	"maxKeywordSuggestions": 25
}
````

`Domains or URLs` controls website-based SEO rows. `Keywords` controls keyword suggestion rows. You can use either list on its own or combine both in one run.

The result toggles let you avoid saving data you do not need. Individual backlink rows are enabled in the default sample so the first run proves the richer domain output. Keyword suggestions are off by default; enable them when you submit keyword seeds. Limits cap top pages, backlinks, and keyword suggestions per submitted target.

### 📊 Output example

```json
{
	"rowType": "keyword_suggestion",
	"target": "automation",
	"normalizedDomain": null,
	"keyword": "automation",
	"country": "us",
	"language": "en",
	"sourceName": "Ubersuggest",
	"sourceUrl": "https://app.neilpatel.com",
	"scrapedAt": "2026-05-27T00:00:00.000Z",
	"inputIndex": 0,
	"suggestion": "automation",
	"volume": 74000,
	"cpc": 2.15,
	"currency": "USD",
	"competition": 0.35,
	"seoDifficulty": 49,
	"paidDifficulty": 42,
	"searchIntent": ["informational"],
	"updatedAt": "2026-05-01",
	"rank": 1,
	"isSeedKeyword": true
}
```

Domain and backlink rows use the same common trace fields, plus the metrics that match their `rowType`.

### 💡 Common use cases

#### 🔑 Keyword expansion

Turn seed topics into Ubersuggest keyword suggestion rows with volume, CPC, difficulty, intent, and rank for content briefs or keyword lists.

#### 🧭 Competitor SEO snapshots

Submit competitor domains and compare authority, organic traffic, paid traffic, top pages, backlinks, and ranking buckets in a dataset or spreadsheet.

#### 🔗 Backlink research

Collect backlink summary data for quick audits, or enable individual backlinks when you need source URLs, anchors, authority metrics, and nofollow status.

#### 🔁 Scheduled monitoring

Schedule the same domains or keywords and compare exported datasets over time. Ubersuggest values can change by market, language, source availability, and collection time.

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each saved Ubersuggest SEO item, such as a domain overview, top page, backlink summary, backlink, or keyword suggestion.

Use the result toggles and limits to control output size. Runs that collect no saved items do not create Ubersuggest SEO item charges.

### ⚠️ Limits and caveats

- Ubersuggest data can vary by country, language, time, and source availability.
- Very narrow keywords or domains with little SEO footprint can return few or no rows.
- Large mixed runs depend on Ubersuggest availability and may return partial sections if the source limits a report.
- The Actor collects public Ubersuggest SEO data only. It does not access private account data, saved projects, site audit dashboards, or logged-in reports.
- Always review high-risk SEO or business decisions against the source data and your own judgment.

### ❓ FAQ

#### 🔐 Do I need a Ubersuggest account?

No. You do not need to provide Ubersuggest credentials, cookies, an API key, or a paid Ubersuggest account.

#### 🌍 Can I choose country and language?

Yes. Use the two-letter `Country` and `Language` inputs, such as `us` and `en`, to request locale-specific Ubersuggest data.

#### 🧾 Can I export the data?

Yes. You can export the Apify dataset as JSON, CSV, Excel, XML, RSS, or HTML, or read it through the Apify API.

#### 📌 Why did a target return fewer rows than my limit?

The limit is a maximum, not a promise that every target has that many available items. Ubersuggest may return fewer rows for narrow keywords, low-visibility domains, or temporarily limited source reports.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~ubersuggest-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Pinterest Keyword Scraper ↗](https://apify.com/maximedupre/pinterest-keyword-scraper) - Collect Pinterest autocomplete keyword ideas for content and Pinterest SEO research.
- [Etsy Keywords Research Tool ↗](https://apify.com/maximedupre/etsy-keywords-research-tool) - Find Etsy autocomplete phrases for listing titles, niches, and product research.
- [Website URL Crawler ↗](https://apify.com/maximedupre/website-url-crawler) - Crawl rendered websites and export link maps for SEO audits and QA.
- [Website Emails Scraper ↗](https://apify.com/maximedupre/website-emails-scraper) - Extract public email addresses from submitted websites for lead and contact workflows.
- [Business Address Scraper ↗](https://apify.com/maximedupre/business-address-scraper) - Find business addresses shown on public company websites.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `domainsOrUrls` (type: `array`):

Enter one domain or URL per line, such as example.com or https://apify.com. Each target can return overview, top page, backlink summary, and backlink items.

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

Enter seed keywords for Ubersuggest keyword suggestions with volume, CPC, competition, SEO difficulty, paid difficulty, and intent.

## `country` (type: `string`):

Two-letter country code for Ubersuggest locale data, such as us, ca, gb, de, fr, or au.

## `language` (type: `string`):

Two-letter language code for Ubersuggest locale data, such as en, fr, de, es, or it.

## `includeOverview` (type: `boolean`):

Save one overview item per domain with authority, backlinks, organic and paid traffic, keyword ranking buckets, history, and country traffic.

## `includeTopPages` (type: `boolean`):

Save ranked top-page items for each domain, including page URL, title, traffic, backlinks, referring domains, and social shares.

## `includeBacklinksOverview` (type: `boolean`):

Save one backlink summary item per domain with authority, referring domains, backlink counts, and follow/nofollow counts.

## `includeBacklinks` (type: `boolean`):

Save individual backlink items for each domain. Enable this only when you need source URLs, anchors, authority metrics, and nofollow status.

## `includeKeywordSuggestions` (type: `boolean`):

Save keyword suggestion items for submitted seeds, including volume, CPC, competition, SEO difficulty, paid difficulty, and intent.

## `maxTopPages` (type: `integer`):

Maximum top-page items to save for each domain.

## `maxBacklinks` (type: `integer`):

Maximum individual backlink items to save for each domain when backlinks are enabled.

## `maxKeywordSuggestions` (type: `integer`):

Maximum keyword suggestion items to save for each keyword seed.

## Actor input object example

```json
{
  "domainsOrUrls": [
    "apify.com",
    "shopify.com"
  ],
  "keywords": [],
  "country": "us",
  "language": "en",
  "includeOverview": true,
  "includeTopPages": true,
  "includeBacklinksOverview": true,
  "includeBacklinks": true,
  "includeKeywordSuggestions": false,
  "maxTopPages": 10,
  "maxBacklinks": 25,
  "maxKeywordSuggestions": 25
}
```

# Actor output Schema

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

Dataset of domain overview, top page, backlink summary, backlink, and keyword suggestion items.

# 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 = {
    "domainsOrUrls": [
        "apify.com",
        "shopify.com"
    ],
    "keywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/ubersuggest-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "domainsOrUrls": [
        "apify.com",
        "shopify.com",
    ],
    "keywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/ubersuggest-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domainsOrUrls": [
    "apify.com",
    "shopify.com"
  ],
  "keywords": []
}' |
apify call maximedupre/ubersuggest-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ubersuggest Scraper",
        "description": "Scrape Ubersuggest SEO data from domains, URLs, and keywords. Export domain overviews, top pages, backlinks, and keyword suggestions without Ubersuggest cookies.",
        "version": "0.0",
        "x-build-id": "l5lnjcRfZFeBOgAiL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~ubersuggest-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-ubersuggest-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~ubersuggest-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-ubersuggest-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~ubersuggest-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-ubersuggest-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "domainsOrUrls": {
                        "title": "Domains or URLs",
                        "type": "array",
                        "description": "Enter one domain or URL per line, such as example.com or https://apify.com. Each target can return overview, top page, backlink summary, and backlink items.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "keywords": {
                        "title": "Keyword seeds",
                        "type": "array",
                        "description": "Enter seed keywords for Ubersuggest keyword suggestions with volume, CPC, competition, SEO difficulty, paid difficulty, and intent.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two-letter country code for Ubersuggest locale data, such as us, ca, gb, de, fr, or au.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Two-letter language code for Ubersuggest locale data, such as en, fr, de, es, or it.",
                        "default": "en"
                    },
                    "includeOverview": {
                        "title": "Include domain overview?",
                        "type": "boolean",
                        "description": "Save one overview item per domain with authority, backlinks, organic and paid traffic, keyword ranking buckets, history, and country traffic.",
                        "default": true
                    },
                    "includeTopPages": {
                        "title": "Include top pages?",
                        "type": "boolean",
                        "description": "Save ranked top-page items for each domain, including page URL, title, traffic, backlinks, referring domains, and social shares.",
                        "default": true
                    },
                    "includeBacklinksOverview": {
                        "title": "Include backlink overview?",
                        "type": "boolean",
                        "description": "Save one backlink summary item per domain with authority, referring domains, backlink counts, and follow/nofollow counts.",
                        "default": true
                    },
                    "includeBacklinks": {
                        "title": "Include backlinks?",
                        "type": "boolean",
                        "description": "Save individual backlink items for each domain. Enable this only when you need source URLs, anchors, authority metrics, and nofollow status.",
                        "default": true
                    },
                    "includeKeywordSuggestions": {
                        "title": "Include keyword suggestions?",
                        "type": "boolean",
                        "description": "Save keyword suggestion items for submitted seeds, including volume, CPC, competition, SEO difficulty, paid difficulty, and intent.",
                        "default": false
                    },
                    "maxTopPages": {
                        "title": "Top pages per domain",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum top-page items to save for each domain.",
                        "default": 10
                    },
                    "maxBacklinks": {
                        "title": "Backlinks per domain",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum individual backlink items to save for each domain when backlinks are enabled.",
                        "default": 25
                    },
                    "maxKeywordSuggestions": {
                        "title": "Suggestions per keyword",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum keyword suggestion items to save for each keyword seed.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```