# Fressnapf Pet Supplies Scraper (`crawlerbros/fressnapf-pet-supplies-scraper`) Actor

Scrape Fressnapf.de - Europe's largest pet-supply retailer. Browse dog, cat, small-animal, bird, fish, reptile, and pond products by category or brand, with prices, ratings, and images.

- **URL**: https://apify.com/crawlerbros/fressnapf-pet-supplies-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Fressnapf Pet Supplies Scraper

Scrape [Fressnapf.de](https://www.fressnapf.de) — Europe's largest pet-supply retailer. Browse dog, cat, small-animal, bird, aquarium/fish, terrarium/reptile, garden & pond, and vet-diet products by category, or browse any of 700+ brands. Get product name, brand, price, rating, and images. HTTP-only, no login, no cookies, no proxy required.

### What this actor does

- **Two modes:** `byCategory` (89 curated pet-type/product-type categories) and `byBrand` (any Fressnapf brand, by name)
- **Full pet-type coverage:** Dog, Cat, Small Animal, Bird, Aquarium & Fish, Terrarium & Reptile, Garden & Pond, and Vet Diets
- **Price filters:** min/max price in EUR
- **Sort:** relevance (site default), price low-to-high, price high-to-low, or rating highest-first
- **Ratings & reviews:** star rating and review count, when shown
- **Empty fields are omitted** — every record only contains fields Fressnapf actually populated

Note: fressnapf.de is a German-language site — product names, brand names, and categories in the output are in German, matching what's shown on the live site.

### Output per product

- `productUrl`, `productId`
- `name`, `brand`
- `price`, `currency` (`EUR`), `pricePerUnit`, `pricePerUnitLabel` (e.g. `kg`, `l`, `Stk`)
- `imageUrl`
- `rating`, `reviewCount`
- `packSizeOptions` — number of pack-size variants available, when the product has more than one
- `sponsored` — `true` if the listing is a sponsored placement
- `category` — pet type (or `Brand: <name>` in byBrand mode)
- `recordType: "product"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byCategory` | `byCategory` / `byBrand` |
| `categoryPath` | select | `hund/hundefutter/trockenfutter` | One of 89 curated categories (mode=byCategory) |
| `customCategoryPath` | string | – | Exact category path override, e.g. `hund/hundefutter/trockenfutter` (advanced) |
| `brand` | string | – | Brand name (mode=byBrand), e.g. `Royal Canin` |
| `sortBy` | string (select) | `relevance` | `relevance` / `priceAsc` / `priceDesc` / `ratingDesc` |
| `minPrice` | int | – | Drop products cheaper than this (EUR) |
| `maxPrice` | int | – | Drop products more expensive than this (EUR) |
| `maxItems` | int | `50` | Hard cap (1–2000) |

#### Example: dog dry food

```json
{
  "mode": "byCategory",
  "categoryPath": "hund/hundefutter/trockenfutter",
  "maxItems": 50
}
````

#### Example: browse a brand

```json
{
  "mode": "byBrand",
  "brand": "Whiskas",
  "maxItems": 50
}
```

#### Example: price-filtered cat toys

```json
{
  "mode": "byCategory",
  "categoryPath": "katze/katzenspielzeug",
  "minPrice": 5,
  "maxPrice": 30
}
```

### Use cases

- **Price monitoring** — track pet-food and supply pricing across brands and categories
- **Market research** — analyze Europe's largest pet retailer's catalog breadth and pricing by pet type
- **Assortment analysis** — compare brand presence and pack-size options across categories
- **Competitive intelligence** — for pet-supply brands and retailers benchmarking against Fressnapf
- **Data feeds** — power a pet-supply price-comparison or deal-alert product

### FAQ

**What's Fressnapf?**  Europe's largest pet-supply retailer, with stores across Germany, Austria, and other European markets and a full e-commerce catalog at fressnapf.de.

**Do I need to log in or use cookies?**  No. All categories and brand pages are publicly browsable without an account.

**Why are product names in German?**  fressnapf.de is a German-language storefront; product names, brand names, and category labels reflect the live site content as-is (no translation), which keeps the data accurate and matchable back to the source.

**How is `categoryPath` structured?**  Each value mirrors fressnapf.de's own URL structure, e.g. `hund/hundefutter/trockenfutter` = Dog > Dog Food > Dry Food. Use `customCategoryPath` to reach any category not in the curated dropdown.

**How do I find a brand's exact name?**  Use the brand name as displayed on the product's brand tag, e.g. `Royal Canin`, `Whiskas`, `Josera`, `Trixie`. The actor normalizes it (lowercase, spaces to hyphens, umlauts transliterated) into Fressnapf's brand-page URL slug.

**Is there a free-text keyword search across the whole catalog?**  No. fressnapf.de's `/search/?query=...` page is rendered client-side (its results widget only populates after JavaScript runs), so a plain HTTP fetch of that URL returns the same generic fallback listing regardless of the query text — confirmed empirically by comparing responses for several unrelated queries. Reproducing real keyword search would require full browser automation, which this actor intentionally avoids to stay fast and cookie/proxy-free. Use `mode=byCategory` (89 curated categories) or `mode=byBrand` instead — both are backed by real, query-independent server-rendered pages.

**What does `pricePerUnit` mean?**  Fressnapf shows a per-kg/per-liter/per-piece reference price next to the pack price (e.g. `5,21€/kg`) so shoppers can compare pack sizes; `pricePerUnitLabel` holds the unit (`kg`, `l`, `Stk`, etc.).

**Is pricing in EUR?**  Yes — fressnapf.de prices are always in EUR.

**Why only 4 sort options, when the live site offers 7?**  fressnapf.de's own "Beliebtheit" (popularity), "Neuheiten" (newest), and "Größter Rabatt" (biggest discount) sort orders are computed by an internal ranking/discount API that isn't exposed via the public category pages this actor reads, so they can't be reliably reproduced. `priceAsc` / `priceDesc` / `ratingDesc` are sorted locally from the same price/rating fields already in the output, so they're fully reliable.

**How fresh is the data?**  Live — each run reads the current category/brand listing pages directly from fressnapf.de.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `categoryPath` (type: `string`):

Pet type and product category to browse.

## `customCategoryPath` (type: `string`):

Exact fressnapf.de category path segment, e.g. `hund/hundefutter/trockenfutter`. Use this to reach a category not listed in the dropdown above.

## `brand` (type: `string`):

Brand name as shown on fressnapf.de, e.g. `Royal Canin`, `Whiskas`, `Trixie`. Matched against the brand's shop-in-shop page.

## `sortBy` (type: `string`):

Order results. `relevance` streams results in the site's own natural order (fastest). The other options collect and sort matching products locally, so they cost extra requests to walk the full category/brand listing before sorting.

## `minPrice` (type: `integer`):

Drop products cheaper than this (EUR).

## `maxPrice` (type: `integer`):

Drop products more expensive than this (EUR).

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

Hard cap on emitted products.

## Actor input object example

```json
{
  "mode": "byCategory",
  "categoryPath": "hund/hundefutter/trockenfutter",
  "brand": "Royal Canin",
  "sortBy": "relevance",
  "maxItems": 50
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped Fressnapf products.

# 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 = {
    "mode": "byCategory",
    "categoryPath": "hund/hundefutter/trockenfutter",
    "brand": "Royal Canin",
    "sortBy": "relevance",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/fressnapf-pet-supplies-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 = {
    "mode": "byCategory",
    "categoryPath": "hund/hundefutter/trockenfutter",
    "brand": "Royal Canin",
    "sortBy": "relevance",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/fressnapf-pet-supplies-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 '{
  "mode": "byCategory",
  "categoryPath": "hund/hundefutter/trockenfutter",
  "brand": "Royal Canin",
  "sortBy": "relevance",
  "maxItems": 50
}' |
apify call crawlerbros/fressnapf-pet-supplies-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fressnapf Pet Supplies Scraper",
        "description": "Scrape Fressnapf.de - Europe's largest pet-supply retailer. Browse dog, cat, small-animal, bird, fish, reptile, and pond products by category or brand, with prices, ratings, and images.",
        "version": "1.0",
        "x-build-id": "SM6oCYlHbSCRvNMqP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~fressnapf-pet-supplies-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-fressnapf-pet-supplies-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/crawlerbros~fressnapf-pet-supplies-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-fressnapf-pet-supplies-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/crawlerbros~fressnapf-pet-supplies-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-fressnapf-pet-supplies-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byCategory",
                            "byBrand"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "byCategory"
                    },
                    "categoryPath": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "hund",
                            "hund/gassi-gehen",
                            "hund/hundefutter/nassfutter",
                            "hund/hundefutter/snacks",
                            "hund/hundefutter/trockenfutter",
                            "hund/hundespielzeug",
                            "hund/pflege-hygiene",
                            "hund/senior",
                            "hund/welpen",
                            "katze",
                            "katze/hygiene-pflege",
                            "katze/katzenfutter/nassfutter",
                            "katze/katzenfutter/snacks",
                            "katze/katzenfutter/trockenfutter",
                            "katze/katzenspielzeug",
                            "katze/kitten",
                            "katze/kratzmoebel",
                            "katze/senior",
                            "katze/sicherheit",
                            "kleintier",
                            "kleintier/arten/hamster",
                            "kleintier/arten/maus",
                            "kleintier/arten/meerschweinchen",
                            "kleintier/arten/zwergkaninchen",
                            "kleintier/kleintierfutter/hauptfutter",
                            "kleintier/kleintierfutter/snacks",
                            "kleintier/kleintierheim",
                            "kleintier/kleintierheim/streu-stroh",
                            "kleintier/kleintierspielzeug",
                            "kleintier/pflege-hygiene",
                            "kleintier/pflege-hygiene/badesand-badehaeuser",
                            "kleintier/pflege-hygiene/kaefigreinigung-hygiene",
                            "kleintier/pflege-hygiene/krallen-fellpflege",
                            "vogel",
                            "vogel/arten/kanarienvogel",
                            "vogel/arten/papagei",
                            "vogel/arten/wellensittich",
                            "vogel/pflege-hygiene",
                            "vogel/vogelfutter/ergaenzungsfutter",
                            "vogel/vogelfutter/hauptfutter",
                            "vogel/vogelfutter/snacks",
                            "vogel/vogelheim",
                            "vogel/vogelspielzeug",
                            "vogel/vogelspielzeug/spielplaetze",
                            "aqua",
                            "aqua/aquarien",
                            "aqua/aquarien/suesswasser-aquarien",
                            "aqua/aquarientechnik",
                            "aqua/einrichtung-zubehoer/bodengrund",
                            "aqua/einrichtung-zubehoer/dekoration",
                            "aqua/fischfutter",
                            "aqua/meerwasseraquaristik",
                            "aqua/nano-aquaristik",
                            "aqua/pflege-hygiene",
                            "terra",
                            "terra/einrichtung-pflege/bodengrund",
                            "terra/einrichtung-pflege/dekoration",
                            "terra/terrarien-technik/beleuchtung",
                            "terra/terrarien-technik/terrarien",
                            "terra/terrarientierfutter",
                            "terra/terrarientierfutter/ergaenzungsfutter",
                            "terra/terrarientierfutter/frostfutter",
                            "terra/terrarientierfutter/hauptfutter",
                            "terra/terrarientierfutter/schildkroetenfutter",
                            "garten-teich",
                            "garten-teich/huehner-bauernhof",
                            "garten-teich/teichfischfutter",
                            "garten-teich/teichpflege",
                            "garten-teich/teichtechnik-zubehoer",
                            "garten-teich/wildtiere",
                            "garten-teich/wildtiere/eichhoernchen",
                            "garten-teich/wildtiere/igel",
                            "garten-teich/wildtiere/insekten",
                            "garten-teich/wildvoegel",
                            "garten-teich/wildvoegel/wildvogelfutter",
                            "vet-diaeten/hund",
                            "vet-diaeten/hund/haut-fell",
                            "vet-diaeten/hund/herz-leber",
                            "vet-diaeten/hund/hypoallergen",
                            "vet-diaeten/hund/nierendiaet",
                            "vet-diaeten/hund/schonkost",
                            "vet-diaeten/hund/uebergewicht",
                            "vet-diaeten/katze",
                            "vet-diaeten/katze/aufbau-rekonvaleszenz",
                            "vet-diaeten/katze/hypoallergen",
                            "vet-diaeten/katze/nierendiaet",
                            "vet-diaeten/katze/schonkost",
                            "vet-diaeten/katze/uebergewicht",
                            "vet-diaeten/katze/urinary"
                        ],
                        "type": "string",
                        "description": "Pet type and product category to browse.",
                        "default": "hund/hundefutter/trockenfutter"
                    },
                    "customCategoryPath": {
                        "title": "Custom category path (advanced, overrides Category)",
                        "type": "string",
                        "description": "Exact fressnapf.de category path segment, e.g. `hund/hundefutter/trockenfutter`. Use this to reach a category not listed in the dropdown above."
                    },
                    "brand": {
                        "title": "Brand name (mode=byBrand)",
                        "type": "string",
                        "description": "Brand name as shown on fressnapf.de, e.g. `Royal Canin`, `Whiskas`, `Trixie`. Matched against the brand's shop-in-shop page."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "priceAsc",
                            "priceDesc",
                            "ratingDesc"
                        ],
                        "type": "string",
                        "description": "Order results. `relevance` streams results in the site's own natural order (fastest). The other options collect and sort matching products locally, so they cost extra requests to walk the full category/brand listing before sorting.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Min price (EUR)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Drop products cheaper than this (EUR)."
                    },
                    "maxPrice": {
                        "title": "Max price (EUR)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Drop products more expensive than this (EUR)."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on emitted products.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
