# iGlobal Business Directory Scraper (`automation-lab/iglobal-business-directory-scraper`) Actor

Scrape iGlobal.co business listings with categories, locations, descriptions, phones, emails, websites, and profile URLs for lead generation.

- **URL**: https://apify.com/automation-lab/iglobal-business-directory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 93.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## iGlobal Business Directory Scraper

Scrape public business listings from iGlobal.co and turn search pages into clean lead lists with names, profile URLs, categories, locations, descriptions, and optional contact details.

Use this actor when you need a lightweight directory scraper for local prospecting, market mapping, enrichment workflows, or data checks across iGlobal country pages.

### What does iGlobal Business Directory Scraper do?

This actor extracts business records from public iGlobal.co search and category pages.

It can start from ready-made iGlobal URLs or build a search page from a keyword and country slug.

When detail enrichment is enabled, the actor opens each public business profile and captures contact fields that are visible on the page.

Typical output includes:

- 🏢 Business name
- 🔗 iGlobal profile URL
- 🏷️ Category tags
- 📍 Address, city, and country
- 📝 Listing description and slogan
- ☎️ Phone number when public
- ✉️ Email when public
- 🌐 Website or external booking URL when public
- 🕒 Open/closed status badge when present
- 📅 Scrape timestamp

### Who is it for?

This scraper is useful for teams that work with business-directory data.

Sales development teams can collect prospect lists by niche and region.

Marketing agencies can map local businesses in a category before outreach.

Data teams can enrich internal company datasets with public profile URLs and contact hints.

Local SEO consultants can discover competitor profiles, categories, and descriptions.

Researchers can sample directory coverage across countries and verticals.

### Why use this scraper?

- ⚡ HTTP-based scraping without a browser
- 🧾 Clean tabular output ready for CSV, JSON, Excel, API, or database export
- 🔎 Search URL provenance for every row
- 📇 Optional detail-page enrichment for richer contact data
- 💸 Pay-per-result pricing designed for small tests and larger lead batches
- 🧰 Works from both iGlobal URLs and keyword/country inputs

### What data can you extract from iGlobal.co?

| Field | Description |
| --- | --- |
| `businessName` | Name shown on the iGlobal listing card |
| `profileUrl` | Public iGlobal profile URL |
| `categoryTags` | Category labels attached to the business |
| `address` | Address or location text |
| `city` | Best-effort city parsed from location/profile metadata |
| `country` | Country from listing/profile metadata when available |
| `description` | Listing snippet or profile description |
| `slogan` | Short slogan text shown on listing cards |
| `statusBadge` | Open/closed or listing status label when visible |
| `phone` | Public phone number from the profile page |
| `email` | Public email address from the profile page |
| `websiteUrl` | First external website/booking URL found on the profile |
| `externalUrls` | Additional external links from the profile |
| `latitude` | Public geo latitude metadata when present |
| `longitude` | Public geo longitude metadata when present |
| `searchUrl` | Search/category URL that produced the row |
| `page` | Search result page number |
| `scrapedAt` | ISO timestamp for the run |

### How much does it cost to scrape iGlobal business listings?

The actor uses pay-per-event pricing.

You pay a small run-start event and a per-result event for each business listing saved to the dataset.

For testing, keep `maxResults` low, for example 10 to 20 records.

For production lead generation, increase `maxPages` and `maxResults` after confirming the query returns useful records.

Final platform pricing is visible on the actor page before you run it.

### How to use it

1. Open the actor on Apify.
2. Paste one or more iGlobal search/category URLs, or enter a keyword and country slug.
3. Set `maxPages` and `maxResults`.
4. Keep `includeDetails` enabled if you need phones, emails, websites, or coordinates.
5. Click **Start**.
6. Download results from the dataset as CSV, JSON, Excel, XML, or via API.

### Input options

#### iGlobal search or category URLs

Use `startUrls` when you already have a page such as:

```text
https://www.iglobal.co/united-states/search/marketing
````

The actor paginates that page with `?page=2`, `?page=3`, and so on until it reaches your page or result limit.

#### Search query

Use `query` when you want the actor to build a search URL for you.

Examples:

- `marketing`
- `dentist`
- `logistics`
- `beauty spas`
- `plumber`

#### Country slug

Use the iGlobal URL country segment, for example:

- `united-states`
- `canada`
- `united-kingdom`
- `australia`
- `india`

#### Maximum pages

`maxPages` controls how many result pages are scanned for each seed URL.

Start with 1 or 2 pages for quick validation.

#### Maximum business listings

`maxResults` is the global cap across all start URLs and pages.

#### Open detail pages

`includeDetails` controls contact enrichment.

Disable it for faster list-only scraping.

Enable it when you want phone numbers, email addresses, website URLs, and geo metadata.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.iglobal.co/united-states/search/marketing" }
  ],
  "maxPages": 1,
  "maxResults": 20,
  "includeDetails": true
}
```

### Example output

```json
{
  "businessName": "Raina Beach Massage Therapy",
  "profileUrl": "https://www.iglobal.co/united-states/pacifica/raina-beach-massage-therapy",
  "categoryTags": ["Beauty & Spas", "Massage"],
  "address": "400 Old County Rd #9 Pacifica, California, 94044",
  "city": "Pacifica",
  "country": "United States",
  "description": "Hello I am Raina Beach...",
  "phone": "16508346228",
  "email": "Rainabeach@gmail.com",
  "websiteUrl": "http://rainabeach.massagetherapy.com/",
  "searchUrl": "https://www.iglobal.co/united-states/search/marketing",
  "page": 1,
  "scrapedAt": "2026-05-20T08:00:00.000Z"
}
```

### Tips for better results

- ✅ Use specific trade keywords instead of very broad words.
- ✅ Use one country slug per run when you want clean regional exports.
- ✅ Keep detail enrichment on for lead generation.
- ✅ Turn detail enrichment off for fast category mapping.
- ✅ Increase `maxResults` only after your first small run returns useful records.
- ✅ Expect some profiles to have no public phone, email, or website.

### Integrations

You can connect the dataset to downstream workflows.

- Send new leads to Google Sheets.
- Export enriched contacts to a CRM.
- Save JSON rows to a database.
- Trigger a webhook after every run.
- Combine with email validation or website crawling actors.
- Use Apify API to run recurring searches for the same niche.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/iglobal-business-directory-scraper').call({
  query: 'marketing',
  country: 'united-states',
  maxPages: 1,
  maxResults: 20,
  includeDetails: true
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/iglobal-business-directory-scraper').call(run_input={
    'query': 'marketing',
    'country': 'united-states',
    'maxPages': 1,
    'maxResults': 20,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~iglobal-business-directory-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"query":"marketing","country":"united-states","maxPages":1,"maxResults":20,"includeDetails":true}'
```

### MCP usage

Use this actor from MCP-capable tools via Apify MCP.

MCP tool URL:

```text
https://mcp.apify.com/?tools=automation-lab/iglobal-business-directory-scraper
```

Claude Code setup:

```bash
claude mcp add apify-iglobal --url "https://mcp.apify.com/?tools=automation-lab/iglobal-business-directory-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-iglobal": {
      "url": "https://mcp.apify.com/?tools=automation-lab/iglobal-business-directory-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 20 iGlobal marketing businesses in the United States."
- "Find iGlobal dentist listings in Canada and return names, phones, and websites."
- "Run the iGlobal scraper for this search URL and export the dataset as CSV."

### Data quality notes

The actor saves public data shown by iGlobal.

Some profiles only contain a listing card and do not include contact fields.

Contact fields depend on what each business made public on its profile page.

Location parsing is best-effort because directory pages may format addresses differently across countries.

### FAQ

#### Can I scrape iGlobal by keyword?

Yes. Use `query` and `country` when you do not already have an iGlobal URL.

#### Can I scrape a specific iGlobal search URL?

Yes. Paste the URL into `startUrls` and the actor will paginate it up to your limits.

### Troubleshooting

#### Why are phone or email fields empty?

The profile may not publish those contact details. Try keeping `includeDetails` enabled and verify the public profile page contains the data.

#### Why did I get fewer records than requested?

The search/category page may have fewer unique public listings than your `maxResults` value, or the actor may reach `maxPages` first.

#### Why is the website field a booking link?

Some iGlobal profiles expose an external booking or company link instead of a homepage. The actor stores the first external URL as `websiteUrl` and all external links in `externalUrls`.

### Legality

This actor extracts publicly available information from iGlobal pages.

You are responsible for using the data lawfully and respecting privacy, marketing, and data-protection rules that apply to your use case.

Do not use scraped contact details for spam or unlawful outreach.

### Related scrapers

Explore related automation-lab actors on Apify:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/yellow-pages-scraper
- https://apify.com/automation-lab/business-directory-scraper
- https://apify.com/automation-lab/website-contact-finder

### Changelog

#### 0.1

Initial version with HTTP search-page scraping, optional detail enrichment, dataset schema, input schema, and pay-per-result charge events.

### Support

If a run does not return the businesses you expect, share the run ID and the input used.

For best support, include one iGlobal URL that shows the expected listing in your browser.

### Limitations

The actor does not log in, bypass private areas, or scrape hidden data.

It only extracts fields available in public HTML.

Very broad queries may include mixed business categories.

### Operational recommendations

Run a small sample first.

Review the dataset.

Then scale `maxPages` and `maxResults` for production exports.

Keep a copy of the `searchUrl` column so your team can trace each lead back to the directory page.

# Actor input Schema

## `startUrls` (type: `array`):

Optional iGlobal.co search/category URLs to scrape. If empty, the actor builds a search URL from Query and Country.

## `query` (type: `string`):

Keyword used when no start URL is supplied, for example marketing, dentist, plumber, or logistics.

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

iGlobal country path used with Query, such as united-states, canada, united-kingdom, india, or australia.

## `maxPages` (type: `integer`):

How many paginated iGlobal result pages to scan for each start URL or query.

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

Maximum number of unique business records to save.

## `includeDetails` (type: `boolean`):

Fetch each profile page to enrich listings with phone, email, website, coordinates, and full description when available.

## `maxRequestRetries` (type: `integer`):

Retry attempts for failed iGlobal HTTP requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.iglobal.co/united-states/search/marketing"
    }
  ],
  "query": "marketing",
  "country": "united-states",
  "maxPages": 1,
  "maxResults": 20,
  "includeDetails": true,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.iglobal.co/united-states/search/marketing"
        }
    ],
    "query": "marketing",
    "country": "united-states",
    "maxPages": 1,
    "maxResults": 20,
    "includeDetails": true,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/iglobal-business-directory-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 = {
    "startUrls": [{ "url": "https://www.iglobal.co/united-states/search/marketing" }],
    "query": "marketing",
    "country": "united-states",
    "maxPages": 1,
    "maxResults": 20,
    "includeDetails": True,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/iglobal-business-directory-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 '{
  "startUrls": [
    {
      "url": "https://www.iglobal.co/united-states/search/marketing"
    }
  ],
  "query": "marketing",
  "country": "united-states",
  "maxPages": 1,
  "maxResults": 20,
  "includeDetails": true,
  "maxRequestRetries": 3
}' |
apify call automation-lab/iglobal-business-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "iGlobal Business Directory Scraper",
        "description": "Scrape iGlobal.co business listings with categories, locations, descriptions, phones, emails, websites, and profile URLs for lead generation.",
        "version": "0.1",
        "x-build-id": "aRWKNcX8yfofraKq7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~iglobal-business-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-iglobal-business-directory-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/automation-lab~iglobal-business-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-iglobal-business-directory-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/automation-lab~iglobal-business-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-iglobal-business-directory-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": {
                    "startUrls": {
                        "title": "iGlobal search or category URLs",
                        "type": "array",
                        "description": "Optional iGlobal.co search/category URLs to scrape. If empty, the actor builds a search URL from Query and Country.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword used when no start URL is supplied, for example marketing, dentist, plumber, or logistics.",
                        "default": "marketing"
                    },
                    "country": {
                        "title": "Country slug",
                        "type": "string",
                        "description": "iGlobal country path used with Query, such as united-states, canada, united-kingdom, india, or australia.",
                        "default": "united-states"
                    },
                    "maxPages": {
                        "title": "Maximum search pages",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many paginated iGlobal result pages to scan for each start URL or query.",
                        "default": 2
                    },
                    "maxResults": {
                        "title": "Maximum business listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique business records to save.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Open detail pages",
                        "type": "boolean",
                        "description": "Fetch each profile page to enrich listings with phone, email, website, coordinates, and full description when available.",
                        "default": true
                    },
                    "maxRequestRetries": {
                        "title": "Request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Retry attempts for failed iGlobal HTTP requests.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```