# Bark.com Profile Scraper (`scrapesage/bark-scraper`) Actor

Extract Bark.com business profiles as structured data (JSON, CSV, Excel) — name, location, categories, ratings, reviews, and contact signals — for lead generation and market research. Fast HTTP-first engine, ~$2 per 1,000 profiles, no subscription. Unofficial, not affiliated with Bark.com.

- **URL**: https://apify.com/scrapesage/bark-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 profile scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Bark.com Profile Scraper

Turn any list of [Bark.com](https://www.bark.com) company-profile URLs into clean, structured JSON — company name, location, categories, ratings, hires, response time, services, and full reviews — on a fast **HTTP-first** engine that scraped 100 profiles in **1 minute 43 seconds** at **~$0.0003 per record** of compute — **~13× faster and ~29× cheaper than the same run on a browser-only engine** — then bills a flat **$0.002 per profile** and nothing else.

> ⚠️ **Unofficial.** This Actor is not affiliated with, endorsed by, or sponsored by Bark.com. "Bark" and "Bark.com" are trademarks of their respective owners, used here only to describe the public website this tool extracts data from.

### What you get

One structured JSON record per profile, ready to drop into a CRM, spreadsheet, or data warehouse:

- **Firmographics** — company name, free-text location, profile image, and the categories the business is listed under. *Use it for lead generation: build targeted prospect lists by city and service.*
- **Reputation signals** — aggregate star rating, total review count, hires on Bark, and stated response time. *Use it for market research: size and benchmark a local service market at a glance.*
- **Service catalog** — the full list of service cards (title + description) each business advertises. *Use it for competitor analysis: see exactly what rivals offer and how they describe it.*
- **Full reviews (optional)** — every review with author, date, star rating, text, service category, and verified flag. *Use it for ICP building: mine real customer language to sharpen your ideal-customer profile and messaging.*

### Supported scope

- **All 11 Bark.com regions:** United States, United Kingdom, Australia, Canada, Ireland, New Zealand, Singapore, South Africa, India, Germany, and France.
- **Both profile URL shapes:** the classic `…/company/{slug}/{id}/` and the newer short `…/b/{slug}/{id}/` form — mix them freely in one run.
- **Full review extraction** — uncapped. If a profile has 200 reviews, you get all 200 (toggle with `includeReviews`).

### Example output

```json
{
  "profileId": "2noOY",
  "slug": "athena-playground",
  "canonicalUrl": "https://www.bark.com/en/us/company/athena-playground/2noOY/",
  "name": "Athena Playground",
  "locationRaw": "4724 Melrose Avenue, Los Angeles, CA",
  "categories": [
    { "name": "Dog & Pet Grooming", "slug": "pet-grooming" }
  ],
  "description": "Athena Playground is a grooming salon offering full-service dog and cat grooming.",
  "ratingValue": 5,
  "reviewCount": 2,
  "hiresOnBark": 1,
  "responseTimeMinutes": 59,
  "services": [
    { "title": "Bathing Package", "description": "We offer a full detangle, bath, blow-dry, and finish." }
  ],
  "logoUrl": "https://d1k8hez1mxkuxw.cloudfront.net/s/avatar_v2/abc123/logo.png",
  "reviews": [
    {
      "author": "AmandaW",
      "datePublished": "2023-10-09",
      "ratingValue": 5,
      "text": "My fur baby always looks like a superstar after a visit here.",
      "category": null,
      "verified": false
    }
  ],
  "scrapedAt": "2026-05-28T12:00:00.000Z"
}
````

`ratingValue` and `reviewCount` are `null` when a profile has no reviews (distinct from a rated zero). The `reviews` array is present only when `includeReviews` is `true`.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | — (required) | Bark profile URLs (`…/company/{slug}/{id}/` or `…/b/{slug}/{id}/`) |
| `includeReviews` | boolean | `false` | Include the full review list per profile |
| `maxItems` | integer (1–10000) | `1000` | Hard cap on profiles scraped & charged — a cost guard against a runaway URL list |
| `maxConcurrency` | integer (1–10) | `5` | Parallel requests; keep low to minimize block risk |
| `minRequestDelayMs` | integer | `2000` | Minimum delay before each request, jittered up to +3s |
| `maxRequestRetries` | integer (1–10) | `5` | Retries per URL, each with a fresh session/IP |
| `useBrowserFallback` | boolean | `true` | Auto-promote a request to a headless browser if HTTP can't parse it |
| `proxyConfiguration` | object | residential | Apify Proxy config — residential is the recommended default |

#### Example inputs

**1. A single profile, fields only (cheapest possible run):**

```json
{
  "startUrls": [
    { "url": "https://www.bark.com/en/us/company/athena-playground/2noOY/" }
  ],
  "includeReviews": false
}
```

**2. A handful of profiles with full reviews:**

```json
{
  "startUrls": [
    { "url": "https://www.bark.com/en/us/company/athena-playground/2noOY/" },
    { "url": "https://www.bark.com/en/gb/company/some-london-plumber/aB3xY/" },
    { "url": "https://www.bark.com/en/au/b/sydney-dog-walker/9KmQ2/" }
  ],
  "includeReviews": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

**3. A large batch with a spend cap:**

```json
{
  "startUrls": [
    { "url": "https://www.bark.com/en/us/company/example-one/AAAAA/" }
  ],
  "includeReviews": true,
  "maxItems": 500,
  "maxConcurrency": 5,
  "minRequestDelayMs": 1000,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Pricing

**$0.002 per profile scraped — that's it.**

- **$2.00 per 1,000 profiles.**
- **No monthly rental.** No subscription, no minimum.
- **No actor-start fee.** A 10-profile run costs $0.02, not a flat platform tax.
- **You only pay for profiles you actually get.** URLs that fail after all retries are recorded in the dataset but are **not** charged.

Pay-per-event billing means the price above covers the scrape; Apify's standard platform usage (compute + proxy) applies as normal, and on the HTTP-first engine that compute is tiny (~$0.0003/record measured).

### How it works

The Actor runs an **HTTP-first** engine: every request first tries a fast, lightweight HTTP fetch and parses the server-rendered HTML directly — no browser, so it's cheap and quick. Bark profile pages are fully server-rendered, so the overwhelming majority of profiles never need anything heavier.

If a request hits a soft-block or a page that can't be parsed over plain HTTP, it **automatically falls back to a real headless Chromium browser** for that request only (controlled by `useBrowserFallback`). Sessions rotate IPs and User-Agents and retire themselves on 403/429, and each request waits a jittered delay to avoid burst patterns. You get the speed and cost of HTTP with the resilience of a browser exactly when — and only when — it's needed.

### FAQ

**How reliable is it?** A 100-profile benchmark run completed 100/100 with zero failures, all served over the fast HTTP path. Failed URLs (if any) are never silently dropped — they land in the dataset as `{ "url": ..., "error": "failed_after_retries" }` so your pipeline always knows what didn't extract.

**What happens if Bark redesigns its profile pages?** Extraction keys off stable schema.org microdata (`itemprop` attributes) plus resilient CSS selectors, so minor layout changes are usually absorbed. If a required field (the company name) ever can't be found on a `200` page, that request fails loudly rather than emitting a half-empty record — your monitoring sees it immediately.

**Can it scale to 100,000 profiles?** Yes. The HTTP path holds ~$0.0003/record of compute, so 100k profiles is roughly $200 in profile charges plus modest platform usage. Raise `maxConcurrency` and `maxItems`, keep residential proxies on, and run it as a normal large Apify job. The `maxItems` cap is also your safety net against an oversized input list.

**How do I get profile URLs to feed it?** Browse or search Bark.com for a category and location (e.g. dog walkers in Chicago), open the listings, and collect the profile URLs — both `…/company/…` and `…/b/…` shapes work. You can also pair this Actor with any Bark listing/search scraper that outputs profile URLs, then pipe those URLs straight into `startUrls`.

### Limitations

- Input is **profile URLs**, not free-text search — bring the URLs you want scraped (see the FAQ for sourcing).
- Reviews are off by default; enable `includeReviews` when you need them.
- This Actor reads only **public** business-profile data — no logins, no private user data, no CAPTCHA bypass.

### License

ISC

# Actor input Schema

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

Bark.com company profile URLs to scrape. Must match the pattern https://www.bark.com/{lang}/{country}/company/{slug}/{id}/ — for example https://www.bark.com/en/us/company/athena-playground/2noOY/.

## `includeReviews` (type: `boolean`):

If true, scrape and return the full review list for each profile. Adds weight per record. Default: false.

## `maxConcurrency` (type: `integer`):

Maximum parallel requests. Higher is faster; lower is gentler on the target site. Default: 5.

## `minRequestDelayMs` (type: `integer`):

Minimum wait time before each request (jittered up to +3 seconds). Default: 2000.

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

How many times to retry a failed request with a fresh session/IP before giving up. Default: 5.

## `useBrowserFallback` (type: `boolean`):

When true, the crawler may auto-promote a request to a headless Chromium browser if it can't be parsed via HTTP — recommended to maximize success rate against bot detection. Disable for cheaper, HTTP-only runs.

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

Hard cap on the number of profiles scraped (and charged for) in a single run. Acts as a cost guard so a mistakenly large URL list can't run up an unexpected bill. Default: 1000.

## `debugRenderPath` (type: `boolean`):

Diagnostic only. When true, every dataset record gets a `_renderedBy` field ('http' / 'browser' / 'unknown') indicating which path served it. Use to measure the HTTP-vs-browser fallback ratio. Off by default to keep customer output clean.

## `proxyConfiguration` (type: `object`):

Apify Proxy configuration. Residential group is strongly recommended for production runs — datacenter IPs are blocked more aggressively on directory sites.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.bark.com/en/us/company/athena-playground/2noOY/"
    }
  ],
  "includeReviews": false,
  "maxConcurrency": 5,
  "minRequestDelayMs": 2000,
  "maxRequestRetries": 5,
  "useBrowserFallback": true,
  "maxItems": 1000,
  "debugRenderPath": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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.bark.com/en/us/company/athena-playground/2noOY/"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/bark-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.bark.com/en/us/company/athena-playground/2noOY/" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/bark-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.bark.com/en/us/company/athena-playground/2noOY/"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapesage/bark-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bark.com Profile Scraper",
        "description": "Extract Bark.com business profiles as structured data (JSON, CSV, Excel) — name, location, categories, ratings, reviews, and contact signals — for lead generation and market research. Fast HTTP-first engine, ~$2 per 1,000 profiles, no subscription. Unofficial, not affiliated with Bark.com.",
        "version": "0.1",
        "x-build-id": "CxzTA5C4jv7LOSEbl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~bark-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-bark-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/scrapesage~bark-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-bark-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/scrapesage~bark-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-bark-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Bark profile URLs",
                        "type": "array",
                        "description": "Bark.com company profile URLs to scrape. Must match the pattern https://www.bark.com/{lang}/{country}/company/{slug}/{id}/ — for example https://www.bark.com/en/us/company/athena-playground/2noOY/.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "includeReviews": {
                        "title": "Include individual reviews",
                        "type": "boolean",
                        "description": "If true, scrape and return the full review list for each profile. Adds weight per record. Default: false.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent requests",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum parallel requests. Higher is faster; lower is gentler on the target site. Default: 5.",
                        "default": 5
                    },
                    "minRequestDelayMs": {
                        "title": "Minimum delay between requests (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum wait time before each request (jittered up to +3 seconds). Default: 2000.",
                        "default": 2000
                    },
                    "maxRequestRetries": {
                        "title": "Max retries per request",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry a failed request with a fresh session/IP before giving up. Default: 5.",
                        "default": 5
                    },
                    "useBrowserFallback": {
                        "title": "Enable headless browser fallback",
                        "type": "boolean",
                        "description": "When true, the crawler may auto-promote a request to a headless Chromium browser if it can't be parsed via HTTP — recommended to maximize success rate against bot detection. Disable for cheaper, HTTP-only runs.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max profiles to scrape",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap on the number of profiles scraped (and charged for) in a single run. Acts as a cost guard so a mistakenly large URL list can't run up an unexpected bill. Default: 1000.",
                        "default": 1000
                    },
                    "debugRenderPath": {
                        "title": "Debug: tag records with rendering path",
                        "type": "boolean",
                        "description": "Diagnostic only. When true, every dataset record gets a `_renderedBy` field ('http' / 'browser' / 'unknown') indicating which path served it. Use to measure the HTTP-vs-browser fallback ratio. Off by default to keep customer output clean.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy configuration. Residential group is strongly recommended for production runs — datacenter IPs are blocked more aggressively on directory sites.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
