# Ferguson Product Catalog Scraper (`automation-lab/ferguson-product-catalog-scraper`) Actor

🛒 Extract Ferguson product listings, IDs, ratings, availability, compliance badges, documents, package data, and technical specifications.

- **URL**: https://apify.com/automation-lab/ferguson-product-catalog-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% 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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Ferguson Product Catalog Scraper

Extract structured Ferguson product catalog data from category and product pages.

Collect product names, brands, canonical URLs, Ferguson part and item numbers, manufacturer IDs, ratings, availability, compliance badges, documents, and technical specifications.

Use the results for procurement research, catalog enrichment, assortment monitoring, manufacturer intelligence, and recurring product feeds.

> The Actor uses public, anonymous Ferguson pages. Account-specific and call-only pricing is not included.

### What does Ferguson Product Catalog Scraper do?

The Actor accepts public Ferguson category and product URLs.

For a category URL, it paginates through product cards until `maxItems` is reached.

For a product URL, it returns one detailed product record.

Enable `includeDetails` to enrich category results from each product page.

Every record includes a canonical Ferguson URL rather than a translation-wrapper URL.

The scraper extracts one consistent entity type: Ferguson products.

### Why use this Ferguson scraper?

Ferguson pages contain useful catalog attributes in several page sections.

This Actor combines those attributes into export-ready JSON records.

- 🧾 Capture Ferguson and manufacturer identifiers.
- 📦 Monitor public pickup and shipping messages.
- ✅ Collect compliance badges and technical properties.
- 📄 Discover specification and installation documents.
- 🔁 Run the same catalog workflow on a schedule.
- 🔗 Export to JSON, CSV, Excel, XML, or RSS through Apify.

You do not need to maintain selectors, pagination logic, storage, or API infrastructure.

### Who is it for?

#### Plumbing and HVAC distributors

Compare public assortments and normalize manufacturer references.

#### Manufacturers

Audit how products and compliance attributes appear in distribution catalogs.

#### Contractors and procurement teams

Build shortlists using item numbers, availability messages, documents, and specifications.

#### Catalog intelligence vendors

Create recurring structured feeds for enrichment and change detection.

#### Data engineers

Connect a Ferguson product extractor to warehouses, sheets, and internal applications.

### What Ferguson data can I extract?

| Field | Meaning |
|---|---|
| `url` | Canonical Ferguson product URL |
| `sourceUrl` | Category or product input that produced the record |
| `brand` | Product brand |
| `title` | Product title |
| `partNumber` | Ferguson part number |
| `itemNumber` | Ferguson item number |
| `manufacturerPartNumber` | Manufacturer part number |
| `rating` | Public customer rating when displayed |
| `imageUrl` | Main product image URL |
| `availability` | Public shipping or pickup messages |
| `complianceBadges` | Displayed compliance labels |
| `colorFinish` | Selected color or finish |
| `packageQuantity` | Each and inner-pack information |
| `breadcrumbs` | Product catalog hierarchy |
| `description` | Product-detail bullets |
| `documents` | Specification and installation links |
| `specifications` | Flexible technical key-value properties |
| `scrapedAt` | ISO timestamp of extraction |

Fields that are not present on a source page are omitted rather than filled with misleading values.

### How to scrape Ferguson products

1. Open the Actor in Apify Console.
2. Add one or more Ferguson category or product URLs.
3. Choose the maximum number of products.
4. Decide whether detailed enrichment is needed.
5. Click **Start**.
6. Preview the dataset while the run is active.
7. Export the finished dataset in your preferred format.

Start with 24 category records to validate your workflow cheaply.

Increase the limit for scheduled assortment jobs.

### Input

```json
{
  "startUrls": [
    {
      "url": "https://www.ferguson.com/category/bathroom-plumbing/bathroom-faucets/"
    }
  ],
  "maxItems": 24,
  "includeDetails": false
}
````

#### `startUrls`

Provide Ferguson category URLs, product URLs, or a mixture of both.

URLs from `www.ferguson.com` are normalized before processing.

#### `maxItems`

Sets a global maximum across all start URLs.

The accepted range is 1 to 10,000 products.

#### `includeDetails`

Keep this disabled for fast catalog-card extraction.

Enable it to add descriptions, documents, package data, breadcrumbs, compliance labels, and specifications.

Detail enrichment performs one additional request per product and therefore takes longer.

### Output example

```json
{
  "url": "https://www.ferguson.com/product/example/7806070.html",
  "sourceUrl": "https://www.ferguson.com/category/kitchen-plumbing/",
  "brand": "Waterstone",
  "title": "Model No. 9800 Single Handle Pull Down Kitchen Faucet in Polished Nickel",
  "partNumber": "W9800PN",
  "itemNumber": "7806070",
  "manufacturerPartNumber": "9800-PN",
  "rating": 4.5,
  "availability": ["Shipping available"],
  "colorFinish": "Polished Nickel",
  "complianceBadges": ["Lead Law Compliant", "ADA Compliant"],
  "documents": [
    {
      "name": "SPECIFICATION",
      "url": "https://fergusonprod.a.bigcontent.io/v1/static/example"
    }
  ],
  "specifications": {
    "Application": "Residential",
    "Flow Rate": "1.75 gpm",
    "Material": "Brass"
  },
  "scrapedAt": "2026-07-13T00:00:00.000Z"
}
```

The exact attributes depend on the selected Ferguson product.

### Category mode versus product mode

Category mode is best for broad assortment discovery.

It returns product identity, IDs, ratings, availability, badges, images, and URLs efficiently.

Product mode is best for SKU enrichment.

A product URL automatically returns detailed page fields.

When category mode uses `includeDetails: true`, each category record is enriched to the same detailed shape.

### How much does it cost to scrape Ferguson products?

The Actor uses pay-per-event pricing: **$0.005 per run** plus one product event for each record saved. Product rates decrease with your Apify plan:

| Apify plan | Price per saved product | 20-product total | 100-product total | 1,000-product total |
|---|---:|---:|---:|---:|
| Free | $0.000066050 | USD 0.006321 | USD 0.011605 | USD 0.071050 |
| Bronze | $0.000057434 | USD 0.006149 | USD 0.010743 | USD 0.062434 |
| Silver | $0.000044799 | USD 0.005896 | USD 0.009480 | USD 0.049799 |
| Gold | $0.000034461 | USD 0.005689 | USD 0.008446 | USD 0.039461 |
| Platinum | $0.000022974 | USD 0.005459 | USD 0.007297 | USD 0.027974 |
| Diamond | $0.000016082 | USD 0.005322 | USD 0.006608 | USD 0.021082 |

Totals include the $0.005 start event. A product event is charged only after a product record is saved. The Apify Console remains the source of truth for current rates.

**Free-plan estimate:** if all $5 of monthly platform credits were available for this Actor, about **791 default 20-product runs (15,820 products)** would fit at the Free rate. Actual capacity is lower because Actor compute and any other platform usage draw from the same credits. Larger runs spend proportionally less on start events.

### Availability and pricing limitations

Availability reflects only the public message rendered by Ferguson at scrape time.

Local inventory can vary by location and selected store.

Treat availability as a monitoring signal, not a stock reservation.

The Actor deliberately excludes account-specific, negotiated, and call-only pricing.

It does not log in, add items to a cart, or impersonate an account holder.

### Data quality tips

- Use canonical category pages rather than navigation or campaign URLs.
- Keep `includeDetails` off when IDs and URLs are sufficient.
- Enable enrichment when specifications or documents are required.
- Schedule comparable inputs at consistent times.
- Use `itemNumber` as a stable key for dataset joins.
- Retain `scrapedAt` when measuring changes.
- Expect specification names to vary by product family.

### Scheduling a Ferguson catalog monitor

Create an Apify schedule after a successful run.

Choose a daily, weekly, or monthly cadence based on assortment volatility.

Store each run in a named dataset or send it to your destination.

Compare records by `itemNumber` or canonical `url`.

Alert on added products, removed products, changed availability, or specification differences.

Apify webhooks can start the downstream comparison automatically.

### Integrations

#### Google Sheets

Send fresh records to a spreadsheet used by buyers or category managers.

#### Airtable

Maintain a searchable SKU and document catalog.

#### Slack and email

Post notifications when a scheduled comparison finds catalog changes.

#### Snowflake, BigQuery, and warehouses

Load normalized product rows into procurement or product intelligence models.

#### Zapier and Make

Trigger no-code workflows when a run finishes.

#### Webhooks

Deliver run and dataset events to your own API.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ferguson-product-catalog-scraper').call({
  startUrls: [{ url: 'https://www.ferguson.com/category/bathroom-plumbing/bathroom-faucets/' }],
  maxItems: 100,
  includeDetails: false,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Use environment variables for API tokens.

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/ferguson-product-catalog-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.ferguson.com/category/bathroom-plumbing/bathroom-faucets/'}],
    'maxItems': 100,
    'includeDetails': False,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Install the official `apify-client` package before running the example.

### API usage with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~ferguson-product-catalog-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.ferguson.com/category/bathroom-plumbing/bathroom-faucets/"}],"maxItems":20,"includeDetails":false}'
```

Read the resulting dataset through the run's `defaultDatasetId`.

### Use with Apify MCP

Connect AI assistants through the actor-scoped Apify MCP endpoint:

`https://mcp.apify.com?tools=automation-lab/ferguson-product-catalog-scraper`

#### Claude Code setup

Register the remote HTTP server from a terminal:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/ferguson-product-catalog-scraper"
```

#### Claude Desktop, Cursor, and VS Code setup

Add this remote server to the client's MCP JSON configuration, save it, and restart or reload the client:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/ferguson-product-catalog-scraper"
    }
  }
}
```

The client will prompt you to authenticate with Apify when it first connects. Once connected, try these actor-specific prompts:

- “Scrape 50 Ferguson bathroom faucet products and summarize brands.”
- “Extract the technical specifications and documents for this Ferguson product URL.”
- “Compare availability fields in my newest Ferguson dataset with the previous run.”

Keep product limits low while designing a prompt-driven workflow.

### Error handling and troubleshooting

The Actor stops with a clear error when Ferguson returns a blocked or unexpectedly short response.

A source with no recognizable product cards is logged and skipped safely.

Results already saved remain available if a later source fails.

#### Why are some detail fields missing?

Not every Ferguson product exposes the same sections.

Enable `includeDetails` and verify the field exists on the public product page.

#### Why is a run slower with enrichment enabled?

Each product requires its own detail-page request.

Disable enrichment when catalog-card fields meet your needs.

#### Why do availability messages differ later?

Ferguson inventory and location context can change between requests.

Use scheduled snapshots rather than treating one scrape as permanent inventory.

### Responsible use and legality

This Actor extracts publicly accessible catalog information.

Users are responsible for complying with applicable law, contractual obligations, and Ferguson's terms.

Do not use the Actor to collect personal data or bypass account access controls.

Use conservative run sizes and schedules.

Do not represent public availability as guaranteed inventory.

Account-specific and call-only prices are outside this Actor's scope.

### FAQ

#### Does it require a Ferguson login?

No. The Actor uses anonymous public product and category pages.

#### Can it scrape a single product?

Yes. Supply a Ferguson product URL in `startUrls`.

#### Can it scrape multiple categories?

Yes. Add multiple category URLs and set one global `maxItems` limit.

#### Does it extract prices?

No. Public pages can show call-only or account-dependent pricing, so v1 omits prices.

#### Can I download PDF documents?

The dataset provides document names and canonical links. Your downstream workflow can download allowed files.

#### Does it support CSV and Excel?

Yes. Export the Apify dataset in CSV, Excel, JSON, XML, or other supported formats.

#### How do I deduplicate products?

Use `itemNumber` or canonical `url` as the key.

### Related scrapers

Explore other catalog and ecommerce tools from [automation-lab](https://apify.com/automation-lab).

Combine this Actor with URL monitoring, document processing, or generic ecommerce workflows in the same Apify account.

Only automation-lab Actor links are recommended here so ownership and support remain clear.

### Support

Open an issue from the Actor's Apify page when a valid Ferguson URL does not return expected public fields.

Include the input URL, run ID, and a short description of the missing data.

Do not include account credentials or private procurement information.

### Start extracting Ferguson catalog data

Use the prefilled bathroom faucet category for a small first run.

Review the dataset schema.

Then increase `maxItems`, enable detail enrichment if needed, and connect the output to your recurring procurement or catalog-intelligence workflow.

# Actor input Schema

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

Public Ferguson category and product URLs to scrape.

## `maxItems` (type: `integer`):

Stop after saving this many Ferguson products across all start URLs.

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

Fetch descriptions, documents, breadcrumbs, package data, compliance badges, and technical specifications. Slower but richer.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.ferguson.com/category/bathroom-plumbing/bathroom-faucets/"
    }
  ],
  "maxItems": 20,
  "includeDetails": false
}
```

# 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.ferguson.com/category/bathroom-plumbing/bathroom-faucets/"
        }
    ],
    "maxItems": 20,
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ferguson-product-catalog-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.ferguson.com/category/bathroom-plumbing/bathroom-faucets/" }],
    "maxItems": 20,
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ferguson-product-catalog-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.ferguson.com/category/bathroom-plumbing/bathroom-faucets/"
    }
  ],
  "maxItems": 20,
  "includeDetails": false
}' |
apify call automation-lab/ferguson-product-catalog-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ferguson Product Catalog Scraper",
        "description": "🛒 Extract Ferguson product listings, IDs, ratings, availability, compliance badges, documents, package data, and technical specifications.",
        "version": "0.1",
        "x-build-id": "NfwIgRYdEfc8QiDv7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ferguson-product-catalog-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ferguson-product-catalog-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~ferguson-product-catalog-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ferguson-product-catalog-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~ferguson-product-catalog-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ferguson-product-catalog-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": "🛒 Ferguson category or product URLs",
                        "type": "array",
                        "description": "Public Ferguson category and product URLs to scrape.",
                        "default": [
                            {
                                "url": "https://www.ferguson.com/category/bathroom-plumbing/bathroom-faucets/"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many Ferguson products across all start URLs.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Enrich from product detail pages",
                        "type": "boolean",
                        "description": "Fetch descriptions, documents, breadcrumbs, package data, compliance badges, and technical specifications. Slower but richer.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
