# B2B URL Finder (`automation-lab/b2b-url-finder`) Actor

Discover B2B company websites from industry, keyword, and location searches. Export clean domains with source snippets and confidence scores.

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

## Pricing

from $0.02 / 1,000 result extracteds

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

## B2B URL Finder

Discover company websites from industry, keyword, and location searches. B2B URL Finder turns public search results into a clean list of unique company domains for prospecting, enrichment, market mapping, and agency lead generation.

### What does B2B URL Finder do?

B2B URL Finder searches lightweight public search result pages, extracts organic result URLs, filters out directories and social networks, canonicalizes company domains, and returns a structured dataset of likely business websites.

It is designed for workflows where you know a market segment but do not already have a company list.

Examples:

- Industrial automation companies in Austin
- B2B SaaS companies in Germany
- Packaging suppliers in Chicago
- Logistics providers in the United Kingdom
- Cybersecurity consulting firms in Toronto

### Who is it for?

Sales development teams use it to discover net-new accounts for outbound campaigns.

Lead generation agencies use it to create first-pass company lists before enrichment.

Recruiters use it to find employer websites in a niche and region.

Market researchers use it to map fragmented local or vertical markets.

No-code operators use it as a repeatable Apify actor that can feed CRM, enrichment, or spreadsheet automations.

### Why use this actor?

- Finds company websites from plain-language B2B search terms
- Deduplicates by root domain
- Filters common non-company sources such as social networks, directories, review portals, and news sites
- Adds confidence scoring and business-signal labels
- Keeps the dataset compact and export-ready
- Runs with HTTP requests, not a heavy browser, for lower cost and faster startup

### How it works

The actor builds search queries from your keywords, optional industry, locations, and country.

It queries DuckDuckGo Lite by default because the HTML is lightweight and stable for HTTP parsing.

Bing can also be selected as a secondary source, but search engines may occasionally show anti-bot challenges.

For each organic result, the actor canonicalizes the result URL to the homepage, extracts the root domain, applies exclusion rules, scores business signals, and saves unique domains.

### Data you get

| Field | Description |
| --- | --- |
| `company` | Best-effort company name derived from the search result title |
| `domain` | Canonical root domain |
| `websiteUrl` | Canonical homepage URL |
| `sourceUrl` | Original search result URL |
| `title` | Organic result title |
| `snippet` | Organic result snippet |
| `matchedKeyword` | Keyword that produced the result |
| `matchedLocation` | Location that produced the result |
| `country` | Optional country/market from input |
| `confidenceScore` | 1-99 score based on keyword, location, and business signals |
| `discoverySource` | Search source used for discovery |
| `businessSignals` | Labels explaining why the result looks like a company website |

### How much does it cost to find B2B company URLs?

Pricing is pay per result: a **$0.005 start charge** plus a low per-company charge.

Current launch pricing is **$0.041209 per 1,000 company websites** on the BRONZE tier before volume discounts. FREE tier runs are **$0.04739 per 1,000 company websites**; higher paid tiers receive automatic volume discounts.

You only pay for unique company websites saved to the dataset.

### Input options

#### Keywords / niches

Provide one or more industries, services, products, or buying-intent phrases.

Good examples:

- `industrial automation companies`
- `managed IT services providers`
- `packaging manufacturers`
- `B2B SaaS companies`

#### Primary industry

Use the optional `industry` field when you have one main target market. It is prepended to the keyword list.

#### Locations

Add cities, states, regions, or markets. Each location is combined with each keyword.

#### Country

Add a country or market name such as `United States`, `Germany`, or `UK`.

#### Maximum company websites

Use `maxResults` to control cost and output size.

Start with 30-50 results while validating your query language.

#### Include domains

Use this advanced field only when you want to allow a known set of exact domains.

Most users should leave it empty.

#### Exclude domains

Add competitors, partners, or known irrelevant domains you do not want in the output.

The actor already excludes many common directory, social, review, and media domains.

#### Require business signals

Keep this enabled for cleaner lead lists. Disable it only when you prefer broader discovery and plan to review results manually.

#### Search source

DuckDuckGo Lite is the default. Bing can be selected for experimentation or fallback coverage.

### Example input

```json
{
  "keywords": ["industrial automation companies"],
  "industry": "B2B SaaS companies",
  "locations": ["Austin"],
  "country": "United States",
  "maxResults": 30,
  "requireBusinessSignals": true,
  "discoverySource": "duckduckgo"
}
````

### Example output item

```json
{
  "company": "Example Automation",
  "domain": "exampleautomation.com",
  "websiteUrl": "https://exampleautomation.com/",
  "sourceUrl": "https://exampleautomation.com/services",
  "title": "Example Automation | Industrial Automation Services",
  "snippet": "Industrial automation solutions for manufacturers and enterprise teams.",
  "matchedKeyword": "industrial automation companies",
  "matchedLocation": "Austin",
  "country": "United States",
  "confidenceScore": 80,
  "discoverySource": "duckduckgo-lite",
  "businessSignals": ["B2B/service terms", "commercial intent"]
}
```

### How to run

1. Open the actor on Apify.
2. Enter one or more B2B keywords.
3. Add optional locations and country.
4. Set `maxResults` to a small number for your first run.
5. Run the actor.
6. Export the dataset as CSV, JSON, Excel, or via API.

### Tips for better results

Use specific B2B language rather than broad consumer terms.

Include words like `companies`, `providers`, `suppliers`, `manufacturers`, `consulting`, or `software`.

Try several related keywords instead of one generic phrase.

Use city + country when searching for local companies.

Review confidence scores before importing into a CRM.

### Integrations

Send results to Google Sheets for review.

Push domains into enrichment tools to find emails, LinkedIn pages, or company size.

Trigger CRM imports after filtering by confidence score.

Use Apify webhooks to start downstream scraping or enrichment actors.

Combine with contact discovery actors to turn company websites into full lead records.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/b2b-url-finder').call({
  keywords: ['industrial automation companies'],
  locations: ['Austin'],
  country: 'United States',
  maxResults: 30
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/b2b-url-finder').call(run_input={
    'keywords': ['industrial automation companies'],
    'locations': ['Austin'],
    'country': 'United States',
    'maxResults': 30,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~b2b-url-finder/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["industrial automation companies"],"locations":["Austin"],"country":"United States","maxResults":30}'
```

### MCP usage

Use the Apify MCP server with Claude Desktop or Claude Code:

`https://mcp.apify.com/?tools=automation-lab/b2b-url-finder`

Claude Code setup:

```bash
claude mcp add apify-b2b-url-finder https://mcp.apify.com/?tools=automation-lab/b2b-url-finder
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-b2b-url-finder": {
      "url": "https://mcp.apify.com/?tools=automation-lab/b2b-url-finder"
    }
  }
}
```

Example prompts:

- "Find 25 industrial automation company websites in Austin and summarize the best domains."
- "Run B2B URL Finder for packaging suppliers in Chicago and return a CSV-ready table."
- "Find B2B SaaS company domains in Germany, then group them by confidence score."

### What this actor is not

It is not an email finder.

It is not a full company enrichment database.

It does not guarantee every result is a qualified sales lead.

It discovers likely company websites from public search results so you can enrich, review, and qualify them in the next step.

### Quality and filtering

The actor removes common non-company domains before saving results.

It deduplicates domains so the same company does not appear multiple times from repeated queries.

Confidence scores are heuristic and should be treated as ranking aids, not truth labels.

### Legality

This actor extracts publicly available search result metadata and public website URLs.

Make sure your use of the output complies with applicable laws, website terms, privacy rules, and your CRM/email policies.

Do not use discovered websites for spam or unlawful outreach.

### FAQ

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

Search engines may return duplicate domains, directories, social pages, or weak results that are filtered out. Broaden keywords or add more locations.

#### Why are some companies not perfect matches?

Public search results are noisy. Use confidence score, snippets, and your own qualification rules before outreach.

#### Why does Bing return no data sometimes?

Bing can show challenge pages to automated HTTP clients. DuckDuckGo Lite is the default because it is more reliable for this use case.

### Related scrapers

Explore other automation-lab actors for lead generation and enrichment:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/domainapify
- https://apify.com/automation-lab/contact-details-scraper

### Changelog

Initial version discovers company URLs from B2B search terms, filters non-company domains, and returns structured company website records.

### Support

If a query returns unexpected results, include the exact input and a few example domains when reporting the issue.

### Development notes

The actor is HTTP-first and uses lightweight HTML parsing.

It stores one dataset item per unique company domain.

It charges the `result` event only after a dataset item is saved.

### Version

0.1.0

# Actor input Schema

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

Industries, services, or buyer-intent phrases to search for.

## `industry` (type: `string`):

Single primary industry to prepend to the keyword list.

## `locations` (type: `array`):

Cities, regions, or markets to combine with each keyword.

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

Optional country name or country code to add to searches.

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

Maximum number of unique company domains to save.

## `includeDomains` (type: `array`):

Optional exact root domains to allow. Leave empty to include any company domain.

## `excludeDomains` (type: `array`):

Root domains to skip in addition to built-in directory/social/media filters.

## `requireBusinessSignals` (type: `boolean`):

Skip weak results unless the title/snippet/domain looks like a company website.

## `discoverySource` (type: `string`):

Search result source to query. DuckDuckGo Lite is the default because it is lightweight and HTTP-friendly.

## Actor input object example

```json
{
  "keywords": [
    "industrial automation companies"
  ],
  "industry": "B2B SaaS companies",
  "locations": [
    "Austin"
  ],
  "country": "United States",
  "maxResults": 20,
  "includeDomains": [],
  "excludeDomains": [
    "example.com"
  ],
  "requireBusinessSignals": true,
  "discoverySource": "duckduckgo"
}
```

# 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 = {
    "keywords": [
        "industrial automation companies"
    ],
    "industry": "B2B SaaS companies",
    "locations": [
        "Austin"
    ],
    "country": "United States",
    "excludeDomains": [
        "example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/b2b-url-finder").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "keywords": ["industrial automation companies"],
    "industry": "B2B SaaS companies",
    "locations": ["Austin"],
    "country": "United States",
    "excludeDomains": ["example.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/b2b-url-finder").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "industrial automation companies"
  ],
  "industry": "B2B SaaS companies",
  "locations": [
    "Austin"
  ],
  "country": "United States",
  "excludeDomains": [
    "example.com"
  ]
}' |
apify call automation-lab/b2b-url-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "B2B URL Finder",
        "description": "Discover B2B company websites from industry, keyword, and location searches. Export clean domains with source snippets and confidence scores.",
        "version": "0.1",
        "x-build-id": "O8F4VhahjbhZhvYWf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~b2b-url-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-b2b-url-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~b2b-url-finder/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-b2b-url-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~b2b-url-finder/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-b2b-url-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords / niches",
                        "type": "array",
                        "description": "Industries, services, or buyer-intent phrases to search for.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "industry": {
                        "title": "Primary industry (optional)",
                        "type": "string",
                        "description": "Single primary industry to prepend to the keyword list."
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities, regions, or markets to combine with each keyword.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country / market",
                        "type": "string",
                        "description": "Optional country name or country code to add to searches."
                    },
                    "maxResults": {
                        "title": "Maximum company websites",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of unique company domains to save.",
                        "default": 20
                    },
                    "includeDomains": {
                        "title": "Only include domains",
                        "type": "array",
                        "description": "Optional exact root domains to allow. Leave empty to include any company domain.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeDomains": {
                        "title": "Exclude domains",
                        "type": "array",
                        "description": "Root domains to skip in addition to built-in directory/social/media filters.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "requireBusinessSignals": {
                        "title": "Require business signals",
                        "type": "boolean",
                        "description": "Skip weak results unless the title/snippet/domain looks like a company website.",
                        "default": true
                    },
                    "discoverySource": {
                        "title": "Search source",
                        "enum": [
                            "duckduckgo",
                            "bing",
                            "both"
                        ],
                        "type": "string",
                        "description": "Search result source to query. DuckDuckGo Lite is the default because it is lightweight and HTTP-friendly.",
                        "default": "duckduckgo"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
