# Thingtesting Scraper - Brands, Reviews & Daily Changes (`growth-installations/thingtesting`) Actor

Scrape Thingtesting's catalogue of ~39,000 emerging consumer brands: profiles, founders, socials, ratings, products, competitors and individual reviews. Each run flags what changed since the last - new brands, new reviews, rating and catalogue moves - so daily schedules return a clean delta feed.

- **URL**: https://apify.com/growth-installations/thingtesting.md
- **Developed by:** [Growth Installations](https://apify.com/growth-installations) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 brand records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

Scrape [Thingtesting](https://thingtesting.com), the directory of roughly 39,000 emerging D2C consumer brands, into a structured, delta-aware daily feed. Every row carries the brand profile, founders, socials, competitors, aggregate consumer signal and individual reviews, with change annotations against your last snapshot so you only pay to enrich what actually moved.

Built for D2C investors tracking early deal flow, competitive-intelligence teams inside consumer brands, PR and affiliate agencies building prospect lists, and brand-strategy consultancies mapping category velocity.

### Why use this Thingtesting scraper

**D2C deal-flow monitoring.** Sort by Created and watch new brand launches land the day they go public. Scouts and early-stage investors get a timestamped feed of newly indexed brands with founders, socials and initial review velocity attached.

**Competitive intelligence.** Every row includes the alternatives Thingtesting lists (nearest N named competitors plus the total size of the competitive set). Track how a category expands and spot emerging challengers before trade press does.

**PR and affiliate prospecting.** Filter by category, review velocity or ships-to region to build outbound lists of brands worth pitching. Founder names, social handles and websites are on every row.

**Velocity and sentiment tracking.** Review counts in the last 7, 30 and 90 days, incentivised-review share, share mentioning a downside, and 4-5 vs 1-2 star split give a per-brand velocity and polarisation signal you can trend week over week without re-enriching the whole catalogue.

### How to use

1. **Pick order and mode.** Use `Created` + `new-and-changed` for daily deal-flow monitoring, or `MostReviewed` + `all` for a one-off snapshot of the biggest brands.
2. **Turn on incremental snapshotting.** Keep `incremental: true` and set `stateStoreName` to a named key-value store (the default unnamed store is wiped every run, breaking deltas).
3. **Set your caps.** `maxBrands` limits enriched rows written; `maxScanned` limits how deep the cheap list-walk goes. Keep `maxScanned` well above `maxBrands`.
4. **Run it.** Inspect the Dataset tab, pick a view, then schedule it daily from the Actor page's right rail.

### How a run works

1. **Scan**, walks the brand list 20 records per request. The list payload already carries the review summary and product count, so change detection costs almost nothing.
2. **Diff**, compares each brand with the snapshot held in a NAMED key-value store and labels it: new, new_reviews, rating_change, catalog_change, marked_rip, revived or unchanged.
3. **Enrich**, fetches full profiles only for the brands you asked for (new, changed or all): company data, founders, socials, certificates, rating distribution, products, alternatives and individual reviews.

### What you get per brand

- Identity and positioning: title, slug, Thingtesting URL, website, status, categories, description, brand story, AI review summary, image
- Company: founders, founder demographics, HQ location, dates founded / launched, certificates, ships-to, all social profiles
- Aggregate consumer signal: average rating, ratings count, would-recommend percent, full 1-5 rating distribution, 4-5 star share, 1-2 star share, polarisation index
- Catalogue: product count plus a sample of products with images and outbound links
- Competitive set: total number of alternatives Thingtesting lists, plus the nearest N named alternatives
- Review-level signal: reviews sampled, average stars of the sample, review counts in the last 7 / 30 / 90 days, newest review date, top review tags, incentivised share, share mentioning a downside, share with photos
- Individual reviews: stars, liked and disliked verbatims, tags, publish date, incentivised flag, helpful / clap / read / reply counts, photos, author username, author review count and level
- Change tracking: what changed, new reviews since last run, previous ratings count and rating, rating delta, previous product count, first seen, previously seen, days since last seen

### Dataset views

Brands, Daily changes, Review signal, Review verbatims, Alternatives, All fields.

Set *Also push reviews to their own dataset* to additionally write one row per review into a named dataset, easier to load into a warehouse than nested arrays.

### Recommended daily schedule input

    {
      "mode": "new-and-changed",
      "order": "Created",
      "maxBrands": 500,
      "maxScanned": 2000,
      "stopAfterConsecutiveUnchanged": 60,
      "includeAlternatives": true,
      "includeReviews": true,
      "maxReviewsPerBrand": 20,
      "incremental": true,
      "stateStoreName": "thingtesting-scraper-state",
      "useApifyProxy": true
    }

A day with no changes finishes in a few seconds and costs effectively nothing, because unchanged brands are never re-enriched.

### Pricing / Cost estimation

Pay-per-event pricing:

- **Actor start**: $0.005 per run.
- **Brand delivered**: $0.002 per enriched brand pushed to the dataset.

No per-request or per-page charges. Costs come only from brands actually delivered.

- **500 brands** (typical daily delta cap) is about $1.00 when fully filled, and effectively $0 on quiet days when unchanged brands are skipped.
- **2,000 brands** is about $4.00.
- **Full 39,000-brand catalogue scan** is about $80 as a one-time cost. Subsequent incremental daily runs typically cost well under $1 because unchanged brands are skipped before enrichment.

The delta model is designed so the expensive first crawl only happens once. Every scheduled day after that only pays for real change.

### Notes and limits

- The API sits behind Cloudflare. Keep *Use Apify Proxy* on; plain datacenter requests get HTTP 403.
- GraphQL introspection is disabled on the source, so the field list was reconstructed by probing. If Thingtesting changes its schema, a field may need updating.
- The brand list overlaps between pages; the Actor de-duplicates within a run.
- Incremental state MUST live in a named key-value store. The default store is recreated on every run.
- Keep detail concurrency modest (4 is the default) to stay polite to the source.

### FAQ, disclaimers, support

**Is scraping Thingtesting legal?** This Actor reads only public brand and review pages, with no circumvention of access controls. You remain responsible for downstream compliance (data-protection law, terms of service of any tool you load this data into, and outbound-contact regulation such as CAN-SPAM or GDPR when using founder or brand contact fields).

**Do I need a Thingtesting account?** No. All data is scraped from public pages.

**What if a field changes or stops returning data?** Thingtesting occasionally restyles its GraphQL schema. Report broken fields via the Issues tab and they will be patched.

**Custom solutions.** For a different cadence, extra fields, private warehouse delivery or a custom competitive-set report for a specific category, reach out through the Issues tab. Custom builds on top of this scraper are available.

# Actor input Schema

## `maxBrands` (type: `integer`):

Upper limit on how many brand records this run pushes to the dataset.
## `maxScanned` (type: `integer`):

How deep to walk the catalogue during the cheap scan pass (20 brands per request). The scan is what detects change, so keep it larger than Max brands.
## `order` (type: `string`):

Created = newest brands first (best for daily new-launch monitoring). MostReviewed = biggest brands first. Recommended / Latest = editorial ordering.
## `filters` (type: `array`):

Optional Thingtesting filter slugs, e.g. a category slug. Leave empty for the whole catalogue.
## `mode` (type: `string`):

new-and-changed = only brands that are new or whose reviews/rating/catalogue moved since the last run (the daily delta feed). new-only = only brands never seen before. all = everything scanned.
## `incremental` (type: `boolean`):

Persist a per-brand snapshot (rating, review count, product count) in a NAMED key-value store so the next run can compute deltas.
## `stateStoreName` (type: `string`):

Named store that holds the snapshot. The default (unnamed) store is wiped every run, so a name is required for daily deltas.
## `stopAfterConsecutiveUnchanged` (type: `integer`):

Early exit for daily runs with Created ordering: once this many already-seen, unchanged brands appear in a row, stop scanning. 0 disables it.
## `enrichDetails` (type: `boolean`):

Second pass: company data, founders, socials, certificates, categories, rating distribution and products.
## `includeAlternatives` (type: `boolean`):

Capture the brands Thingtesting lists as alternatives, plus the total size of that competitive set.
## `alternativesTake` (type: `integer`):

How many named alternatives to keep per brand.
## `includeReviews` (type: `boolean`):

Capture review-level rows: stars, liked / disliked verbatims, tags, author, helpful count and the incentivised flag.
## `maxReviewsPerBrand` (type: `integer`):

Newest N reviews per brand. Up to 100 come back in a single request; higher values paginate.
## `reviewOrder` (type: `string`):

Latest is what you want for velocity and freshness tracking.
## `includeReviewText` (type: `boolean`):

Turn off to keep only ratings, tags and metadata (smaller dataset).
## `pushReviewsDataset` (type: `boolean`):

Writes one row per review to a named dataset, which is easier to load into a warehouse than nested arrays.
## `reviewsDatasetName` (type: `string`):

Name of the named dataset that receives one row per review.
## `detailConcurrency` (type: `integer`):

Parallel brand-detail requests. Keep it modest to stay polite.
## `requestDelayMs` (type: `integer`):

Pause between requests, applied per concurrency lane.
## `maxRetries` (type: `integer`):

How many times to retry a failed GraphQL request before giving up.
## `useApifyProxy` (type: `boolean`):

Required in practice: the Thingtesting API is behind Cloudflare and blocks datacenter-plain requests with HTTP 403.

## Actor input object example

```json
{
  "maxBrands": 200,
  "maxScanned": 2000,
  "order": "Created",
  "filters": [],
  "mode": "new-and-changed",
  "incremental": true,
  "stateStoreName": "thingtesting-scraper-state",
  "stopAfterConsecutiveUnchanged": 0,
  "enrichDetails": true,
  "includeAlternatives": true,
  "alternativesTake": 12,
  "includeReviews": true,
  "maxReviewsPerBrand": 20,
  "reviewOrder": "Latest",
  "includeReviewText": true,
  "pushReviewsDataset": false,
  "reviewsDatasetName": "thingtesting-reviews",
  "detailConcurrency": 4,
  "requestDelayMs": 200,
  "maxRetries": 4,
  "useApifyProxy": true
}
````

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("growth-installations/thingtesting").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("growth-installations/thingtesting").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 '{}' |
apify call growth-installations/thingtesting --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Thingtesting Scraper - Brands, Reviews & Daily Changes",
        "description": "Scrape Thingtesting's catalogue of ~39,000 emerging consumer brands: profiles, founders, socials, ratings, products, competitors and individual reviews. Each run flags what changed since the last - new brands, new reviews, rating and catalogue moves - so daily schedules return a clean delta feed.",
        "version": "0.0",
        "x-build-id": "guZVrgx0zuwXMnKVE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/growth-installations~thingtesting/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-growth-installations-thingtesting",
                "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/growth-installations~thingtesting/runs": {
            "post": {
                "operationId": "runs-sync-growth-installations-thingtesting",
                "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/growth-installations~thingtesting/run-sync": {
            "post": {
                "operationId": "run-sync-growth-installations-thingtesting",
                "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": {
                    "maxBrands": {
                        "title": "Max brands to output",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Upper limit on how many brand records this run pushes to the dataset.",
                        "default": 200
                    },
                    "maxScanned": {
                        "title": "Max brands to scan",
                        "minimum": 20,
                        "type": "integer",
                        "description": "How deep to walk the catalogue during the cheap scan pass (20 brands per request). The scan is what detects change, so keep it larger than Max brands.",
                        "default": 2000
                    },
                    "order": {
                        "title": "Catalogue sort order",
                        "enum": [
                            "Created",
                            "Latest",
                            "Recommended",
                            "MostReviewed"
                        ],
                        "type": "string",
                        "description": "Created = newest brands first (best for daily new-launch monitoring). MostReviewed = biggest brands first. Recommended / Latest = editorial ordering.",
                        "default": "Created"
                    },
                    "filters": {
                        "title": "Category / attribute filters",
                        "type": "array",
                        "description": "Optional Thingtesting filter slugs, e.g. a category slug. Leave empty for the whole catalogue.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "mode": {
                        "title": "What to output",
                        "enum": [
                            "new-and-changed",
                            "new-only",
                            "all"
                        ],
                        "type": "string",
                        "description": "new-and-changed = only brands that are new or whose reviews/rating/catalogue moved since the last run (the daily delta feed). new-only = only brands never seen before. all = everything scanned.",
                        "default": "new-and-changed"
                    },
                    "incremental": {
                        "title": "Remember state between runs",
                        "type": "boolean",
                        "description": "Persist a per-brand snapshot (rating, review count, product count) in a NAMED key-value store so the next run can compute deltas.",
                        "default": true
                    },
                    "stateStoreName": {
                        "title": "State key-value store name",
                        "type": "string",
                        "description": "Named store that holds the snapshot. The default (unnamed) store is wiped every run, so a name is required for daily deltas.",
                        "default": "thingtesting-scraper-state"
                    },
                    "stopAfterConsecutiveUnchanged": {
                        "title": "Stop after N consecutive unchanged brands",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Early exit for daily runs with Created ordering: once this many already-seen, unchanged brands appear in a row, stop scanning. 0 disables it.",
                        "default": 0
                    },
                    "enrichDetails": {
                        "title": "Fetch full brand profiles",
                        "type": "boolean",
                        "description": "Second pass: company data, founders, socials, certificates, categories, rating distribution and products.",
                        "default": true
                    },
                    "includeAlternatives": {
                        "title": "Include alternatives (competitive set)",
                        "type": "boolean",
                        "description": "Capture the brands Thingtesting lists as alternatives, plus the total size of that competitive set.",
                        "default": true
                    },
                    "alternativesTake": {
                        "title": "Alternatives per brand",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many named alternatives to keep per brand.",
                        "default": 12
                    },
                    "includeReviews": {
                        "title": "Include individual reviews",
                        "type": "boolean",
                        "description": "Capture review-level rows: stars, liked / disliked verbatims, tags, author, helpful count and the incentivised flag.",
                        "default": true
                    },
                    "maxReviewsPerBrand": {
                        "title": "Reviews per brand",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Newest N reviews per brand. Up to 100 come back in a single request; higher values paginate.",
                        "default": 20
                    },
                    "reviewOrder": {
                        "title": "Review sort order",
                        "enum": [
                            "Latest",
                            "Oldest",
                            "Recommended"
                        ],
                        "type": "string",
                        "description": "Latest is what you want for velocity and freshness tracking.",
                        "default": "Latest"
                    },
                    "includeReviewText": {
                        "title": "Include review verbatim text",
                        "type": "boolean",
                        "description": "Turn off to keep only ratings, tags and metadata (smaller dataset).",
                        "default": true
                    },
                    "pushReviewsDataset": {
                        "title": "Also push reviews to their own dataset",
                        "type": "boolean",
                        "description": "Writes one row per review to a named dataset, which is easier to load into a warehouse than nested arrays.",
                        "default": false
                    },
                    "reviewsDatasetName": {
                        "title": "Reviews dataset name",
                        "type": "string",
                        "description": "Name of the named dataset that receives one row per review.",
                        "default": "thingtesting-reviews"
                    },
                    "detailConcurrency": {
                        "title": "Detail concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Parallel brand-detail requests. Keep it modest to stay polite.",
                        "default": 4
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Pause between requests, applied per concurrency lane.",
                        "default": 200
                    },
                    "maxRetries": {
                        "title": "Max retries per request",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry a failed GraphQL request before giving up.",
                        "default": 4
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Required in practice: the Thingtesting API is behind Cloudflare and blocks datacenter-plain requests with HTTP 403.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```