# IQS Directory Scraper (`solidcode/iqsdirectory-scraper`) Actor

\[💰 $2.5 / 1K] Extract industrial supplier and manufacturer listings from IQSDirectory.com. Get company name, address, phone, website, description, certifications, and product categories — by category or company URL.

- **URL**: https://apify.com/solidcode/iqsdirectory-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

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

## IQS Directory Scraper

Pull industrial supplier and manufacturer listings from IQS Directory at scale — company names, full US addresses, direct phone and fax, websites, quality certifications, and the product categories each company serves. One clean row per company, ready for your CRM or sourcing sheet. Built for procurement teams, manufacturers' sales reps, and supply-chain analysts who need a structured supplier list without copying companies off the directory one card at a time.

### Why This Scraper?

- **15 ready-to-pick product categories** — CNC Machining, Metal Stamping, Injection Molding, Die Casting, Springs, Gears, Forgings, Wire Forming, Conveyors, Electric Motors, Plastic Molding, Rubber Molding, Sheet Metal Fabrication, Pressure Vessels, and Heat Exchangers — selected from a plain-English dropdown, no URL hunting required.
- **20+ quality certifications detected per company** — ISO 9001, ISO 13485, ISO 14001, AS9100, IATF 16949, ITAR, NADCAP, RoHS, REACH, ASME, FDA, MIL-SPEC, and API spec numbers, pulled out as a clean array instead of being buried in paragraph text.
- **Full structured US address** — street, city, state, and ZIP delivered as separate fields, so you can sort by state or filter by region the moment the data lands in a spreadsheet.
- **Direct phone AND fax** — both contact numbers per company, captured straight from the profile, not just a click-to-call link.
- **Paste any IQS Directory URL** — target a niche category page or drop in a single company profile link; URL-baked filters are honored exactly as you set them on the site.
- **Profile-level enrichment toggle** — flip one switch to open each company's profile for the full description, certifications, fax, and complete category list, or leave it off for a fast name + location + phone sweep.
- **Clean result cap, not a page cap** — ask for exactly the number of companies you want; no guessing how many "pages" map to how many suppliers.
- **Up to 100,000 companies per run** — sweep an entire category's supplier pool, or set a tight cap to sample a market in seconds.

### Use Cases

**Procurement & Sourcing**
- Build a shortlist of qualified suppliers for a new part or program
- Find backup and second-source manufacturers in a single category
- Screen vendors by certification before sending an RFQ
- Map domestic suppliers by state to shorten lead times

**Sales Lead Generation**
- Build call lists of manufacturers with direct phone and fax numbers
- Target reps' territories by state and product category
- Enrich an existing prospect list with websites and descriptions
- Identify companies that hold a specific certification you sell into

**Competitive & Market Research**
- Size the supplier landscape for a product category
- Track which manufacturers serve adjacent categories
- Benchmark certifications held across a competitive set
- Spot companies offering complementary capabilities

**Supply-Chain Mapping**
- Inventory available manufacturers across multiple categories at once
- Cross-reference suppliers by the full list of categories they serve
- Identify aerospace- or medical-grade vendors via AS9100 / ISO 13485
- Maintain a refreshed master list of approved-vendor candidates

### Getting Started

#### Quick Start — Pick a Category

The simplest run — just choose a product category:

```json
{
    "category": "cnc-machining",
    "maxResults": 100
}
````

#### Full Detail with a Cap

Enrich every company from its profile page for certifications, fax, and the complete category list:

```json
{
    "category": "metal-stampings",
    "scrapeCompanyDetails": true,
    "maxResults": 500
}
```

#### Paste Your Own URLs

Mix a category listing page and a single company profile in one run:

```json
{
    "searchUrls": [
        "https://www.iqsdirectory.com/springs/",
        "https://www.iqsdirectory.com/profile/acme-spring-company-12345/"
    ],
    "scrapeCompanyDetails": true,
    "maxResults": 1000
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchUrls` | array | `[]` | Paste one or more IQS Directory URLs — category listing pages or individual company profile pages. Filters baked into the URL are honored as-is. Leave blank to use the Category picker. |
| `category` | select | `CNC Machining` | Pick a popular product category: CNC Machining, Metal Stamping, Injection Molding, Die Casting, Springs, Gears, Forgings, Wire Forming, Conveyors, Electric Motors, Plastic Molding, Rubber Molding, Sheet Metal Fabrication, Pressure Vessels, or Heat Exchangers. Ignored when you paste URLs. |

#### Detail Level & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `scrapeCompanyDetails` | boolean | `true` | When on, opens each company's profile for the full description, certifications, fax, and complete category list. When off, returns only the faster listing-card data (name, location, phone, website, short blurb). |
| `maxResults` | integer | `100` | Maximum number of companies to collect across all categories and URLs. Set to `0` for no cap. The actor keeps the full final page even if it slightly overshoots your number. |

### Output

Each company is one flat row. Here's a representative result with full detail enabled:

```json
{
    "name": "Acme Precision Machining, Inc.",
    "street": "1450 Industrial Parkway",
    "city": "Cleveland",
    "state": "OH",
    "zip": "44114",
    "address": "1450 Industrial Parkway, Cleveland, OH 44114",
    "phone": "216-555-0142",
    "fax": "216-555-0143",
    "website": "https://www.acmeprecision.com",
    "description": "Acme Precision Machining is an ISO 9001 and AS9100 certified CNC machining shop serving aerospace and medical markets since 1978...",
    "category": "CNC Machining",
    "categories": ["CNC Machining", "Swiss Screw Machining", "Wire EDM"],
    "certifications": ["ISO 9001", "AS9100", "ITAR"],
    "videoUrl": "https://www.youtube.com/watch?v=example",
    "profileUrl": "https://www.iqsdirectory.com/profile/acme-precision-machining-12345/",
    "sourceUrl": "https://www.iqsdirectory.com/cnc-machining/"
}
```

#### Company & Contact

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Company name |
| `phone` | string | Primary phone number |
| `fax` | string | Fax number (from the profile, when present) |
| `website` | string | Company website URL |
| `description` | string | Company description or capabilities blurb |

#### Address

| Field | Type | Description |
|-------|------|-------------|
| `street` | string | Street address (full-detail mode) |
| `city` | string | City |
| `state` | string | State or province |
| `zip` | string | ZIP / postal code (full-detail mode) |
| `address` | string | Full single-line address as displayed |

#### Classification & Source

| Field | Type | Description |
|-------|------|-------------|
| `category` | string | The IQS category under which the company was found |
| `categories` | array | All product categories the company is listed under (full-detail mode) |
| `certifications` | array | Quality certifications detected (ISO 9001, AS9100, ITAR, and more) |
| `videoUrl` | string | Product or company video URL, when available |
| `profileUrl` | string | IQS Directory company profile URL |
| `sourceUrl` | string | The listing URL the company was collected from |

### Tips for Best Results

- **Page one is a curated featured set** — raise `maxResults` past the first handful of cards to reach a category's full supplier pool, which lives on the deeper listing pages.
- **Leave `scrapeCompanyDetails` on for certifications and fax** — those fields only appear on profile pages. Turn it off when you just need a fast name + location + phone sweep across many companies.
- **Use the dropdown for the 15 popular categories, paste a URL for anything niche** — for a category not in the picker, copy its IQS Directory listing URL into `searchUrls`.
- **Filter aerospace and medical suppliers by certification** — sort the output by the `certifications` array for AS9100 (aerospace) or ISO 13485 (medical device) to instantly isolate qualified vendors.
- **Sort by `state` to plan domestic sourcing** — the split address fields let you group suppliers by region without parsing a single address string.
- **Mix categories and URLs in one run** — combine a dropdown category with pasted profile and listing URLs to build a multi-category master list in a single pass.
- **Start with a small `maxResults`** — run 50–100 first to confirm the categories and fields match your needs, then scale up.

### Pricing

**From $2.50 per 1,000 results** — well below the typical industrial-directory scraper rate, with no surprises on the bill. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.30 | $0.28 | $0.265 | $0.25 |
| 1,000 | $3.00 | $2.80 | $2.65 | $2.50 |
| 10,000 | $30.00 | $28.00 | $26.50 | $25.00 |
| 100,000 | $300.00 | $280.00 | $265.00 | $250.00 |

No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. A "result" is one company row in the output dataset. Platform usage fees depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate B2B research, supplier sourcing, and sales prospecting. Users are responsible for complying with applicable laws and IQS Directory's Terms of Service. The data collected is business contact information published for trade purposes — use it for outreach and analysis that respects anti-spam regulations, and do not use it for harassment or any unlawful purpose.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste one or more IQSDirectory.com URLs. Accepts category listing pages (e.g. https://www.iqsdirectory.com/cnc-machining/) or individual company profile pages. Filters baked into the URL are honored as-is. Leave blank to use the Category picker below.

## `category` (type: `string`):

Pick a popular industrial product category to scrape. Ignored when you paste URLs above. For a category not listed here, paste its IQS Directory URL into the field above instead.

## `scrapeCompanyDetails` (type: `boolean`):

When on, the actor opens each company's profile page to capture the full description, certifications, fax, and complete product category list. When off, it returns only the faster listing-card data (name, location, phone, website, short blurb). Turn off for quicker, cheaper runs.

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

Maximum number of companies to collect across all categories and URLs. Default 100 — increase for bigger runs, or set to 0 for no cap (an internal upper limit of 100,000 still applies to prevent runaway pagination). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots.

## Actor input object example

```json
{
  "searchUrls": [],
  "category": "cnc-machining",
  "scrapeCompanyDetails": true,
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped companies with the most useful columns at a glance.

# 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 = {
    "searchUrls": [],
    "category": "cnc-machining",
    "scrapeCompanyDetails": true,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/iqsdirectory-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 = {
    "searchUrls": [],
    "category": "cnc-machining",
    "scrapeCompanyDetails": True,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/iqsdirectory-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 '{
  "searchUrls": [],
  "category": "cnc-machining",
  "scrapeCompanyDetails": true,
  "maxResults": 100
}' |
apify call solidcode/iqsdirectory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "IQS Directory Scraper",
        "description": "[💰 $2.5 / 1K] Extract industrial supplier and manufacturer listings from IQSDirectory.com. Get company name, address, phone, website, description, certifications, and product categories — by category or company URL.",
        "version": "1.0",
        "x-build-id": "0U3kRcqF03H7m7MEl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~iqsdirectory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-iqsdirectory-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/solidcode~iqsdirectory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-iqsdirectory-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/solidcode~iqsdirectory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-iqsdirectory-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": {
                    "searchUrls": {
                        "title": "IQS Directory URLs",
                        "type": "array",
                        "description": "Paste one or more IQSDirectory.com URLs. Accepts category listing pages (e.g. https://www.iqsdirectory.com/cnc-machining/) or individual company profile pages. Filters baked into the URL are honored as-is. Leave blank to use the Category picker below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Product Category",
                        "enum": [
                            "cnc-machining",
                            "metal-stampings",
                            "injection-molding",
                            "die-castings",
                            "springs",
                            "gears",
                            "forgings",
                            "wire-forming",
                            "conveyors",
                            "electric-motors",
                            "plastic-molding",
                            "rubber-molding",
                            "sheet-metal-fabrication",
                            "pressure-vessels",
                            "heat-exchangers"
                        ],
                        "type": "string",
                        "description": "Pick a popular industrial product category to scrape. Ignored when you paste URLs above. For a category not listed here, paste its IQS Directory URL into the field above instead.",
                        "default": "cnc-machining"
                    },
                    "scrapeCompanyDetails": {
                        "title": "Visit each company profile for full details",
                        "type": "boolean",
                        "description": "When on, the actor opens each company's profile page to capture the full description, certifications, fax, and complete product category list. When off, it returns only the faster listing-card data (name, location, phone, website, short blurb). Turn off for quicker, cheaper runs.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of companies to collect across all categories and URLs. Default 100 — increase for bigger runs, or set to 0 for no cap (an internal upper limit of 100,000 still applies to prevent runaway pagination). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
