# Tattoo Artist Directory Scraper - Tattoodo.com (`jungle_synthesizer/tattoo-piercing-shop-directory-scraper`) Actor

Scrape verified tattoo-artist profiles from Tattoodo.com — the global tattoo directory. Returns artist name, studio location, hourly and minimum rates, primary and secondary styles, ratings, biography, social links, and geo coordinates. Filter by country, style, or booking availability.

- **URL**: https://apify.com/jungle\_synthesizer/tattoo-piercing-shop-directory-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Lead generation, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## Tattoodo Tattoo Artist Directory Scraper

Scrape verified tattoo-artist profiles from [Tattoodo](https://www.tattoodo.com/) — the global tattoo discovery platform. Returns artist name, studio name and address, primary and secondary tattoo styles, hourly and minimum rates, ratings, review counts, biography, social links, geo-coordinates, and ~25 other fields per profile.

The actor walks Tattoodo's public partners sitemap (~1,600 verified artists across the US, UK, EU, LATAM, and APAC), fetches each profile, and extracts structured data from the page's embedded state blob with JSON-LD as a fallback. No proxy. No browser. Server-rendered HTML, parsed once per artist.

---

### Tattoodo Scraper Features

- Returns artist name, username, studio name, full address, city, country, and timezone
- Extracts primary and secondary tattoo styles — Black & Gray, Realism, Traditional, Neo Traditional, Blackwork, Fineline, Watercolor, Japanese, Dotwork, Geometric, Lettering, and a long tail
- Captures hourly rate, minimum charge, daily rate, and Tattoodo's symbolic price tier ($–$$$$)
- Returns review count, average rating (0–5), portfolio size, and verification level
- Surfaces booking availability — whether the artist takes bookings through Tattoodo and their typical response time
- Parses Instagram, TikTok, and personal-website links from the artist's social block
- Filters by country code, by style slug, or by bookable-only artists
- Sitemap-driven discovery. The actor finds every verified artist in the public directory, then narrows to the slice you asked for.
- No proxy required. Runs at eight concurrent requests against CloudFront-fronted HTML.

---

### Who Uses Tattoo Artist Data?

- **Booking-software vendors** (Booksy, Squire, GlossGenius) — build outbound lists of bookable artists segmented by country and price tier.
- **Tattoo-supply wholesalers** (Eternal Ink, FK Irons, Electrum) — qualify shops by hourly rate as a proxy for premium-supply purchase intent.
- **Specialty insurance brokers** — source verified artists for outreach on shop and apprenticeship coverage.
- **Apprenticeship programs and trade schools** — find established artists by region and style for partnership and referral programs.
- **Payment processors** — target the long tail of independent artists who accept bookings online and need card processing built for the trade.
- **Travel and tourism platforms** — assemble curated artist directories by city for tattoo-tourism content.

---

### How the Tattoodo Scraper Works

1. The actor fetches Tattoodo's sitemap index and pulls the partners sitemap, which lists every verified artist profile URL.
2. URLs are deterministically shuffled and sliced down to a target count. When filters are tight, the actor over-collects so enough records survive after the country, style, or bookable filter is applied.
3. Each profile page is fetched once. The actor parses the embedded state blob, falls back to the JSON-LD block when the blob is missing, and writes one cleaned record per artist.
4. The run stops as soon as `maxItems` is hit. No babysitting, no manual pagination.

---

### Tattoodo Scraper Input

| Field | Type | Default | Description |
|---|---|---|---|
| `maxItems` | integer | `10` | Maximum number of artist profiles to return. The verified-artist directory has ~1,600 records — set higher for fuller harvests. |
| `countries` | array | `[]` | ISO 3166-1 alpha-2 country codes to keep (e.g. `["US", "GB", "DE"]`). Empty = all countries. |
| `styles` | array | `[]` | Tattoo styles to keep (case-insensitive substring match against style slugs and labels). Empty = all styles. |
| `bookableOnly` | boolean | `false` | When `true`, returns only artists who accept bookings through Tattoodo. |

#### Input Examples

**Default — first 10 verified artists, no filters:**
```json
{
    "maxItems": 10
}
````

**US-based artists, bookable only:**

```json
{
    "countries": ["US"],
    "bookableOnly": true,
    "maxItems": 100
}
```

**Realism specialists across the UK and Germany:**

```json
{
    "countries": ["GB", "DE"],
    "styles": ["realism"],
    "maxItems": 50
}
```

**Full harvest of every verified artist:**

```json
{
    "maxItems": 2000
}
```

***

### Tattoodo Scraper Output Fields

```json
{
    "shopOrArtistName": "Ben Twentyman",
    "username": "ben_tattoos",
    "kind": "artist",
    "biography": "Meet Ben, a tattoo artist based in Manchester with a passion for tattooing animals, florals, anything nerdy...",
    "verificationLevel": 3,
    "primaryStyles": "Black & Gray",
    "secondaryStyles": "Dotwork, Anime, Neo Traditional, Floral, New School, Blackwork, Fineline, Realism",
    "specialties": null,
    "features": null,
    "hourlyRate": "90 GBP",
    "minimumRate": "60 GBP",
    "dailyRate": null,
    "priceTier": "£",
    "portfolioSize": 208,
    "reviewCount": 95,
    "reviewAverage": 5,
    "bookingsAllowed": true,
    "availability": "Next week",
    "responseTime": "2 days",
    "shopName": "116",
    "address": "15 pollard yard east, Manchester, Manchester",
    "city": "Manchester",
    "country": "GB",
    "timezone": "Europe/London",
    "phone": null,
    "latitude": 53.4848325,
    "longitude": -2.2135438,
    "socialLinks": null,
    "instagram": null,
    "tiktok": null,
    "website": null,
    "imageUrl": "https://d1kq2dqeox7x40.cloudfront.net/images/profile-images/2cc3058c-b2f0-44a8-b033-90878f49b9c4.jpeg",
    "profileUrl": "https://www.tattoodo.com/artists/ben_tattoos",
    "scrapedAt": "2026-05-01T23:14:59.978Z"
}
```

| Field | Type | Description |
|---|---|---|
| `shopOrArtistName` | string | Display name of the artist |
| `username` | string | Tattoodo username slug used in the canonical profile URL |
| `kind` | string | Record type — currently always `artist`. Tattoodo's studio endpoint redirects, so the public directory is artists-only. |
| `biography` | string | Artist biography / about-me text |
| `verificationLevel` | integer | Tattoodo's verification tier (0–3). Verified artists have demonstrated professional experience and safety standards. |
| `primaryStyles` | string | Comma-separated primary tattoo styles |
| `secondaryStyles` | string | Comma-separated secondary tattoo styles |
| `specialties` | string | Comma-separated specialties listed by the artist (often empty) |
| `features` | string | Comma-separated artist features (e.g. `Cover-ups, Vegan Ink, Experience tattooing darker skin`) |
| `hourlyRate` | string | Hourly rate as a currency-tagged string (e.g. `$120`, `90 GBP`). Empty when not disclosed. |
| `minimumRate` | string | Minimum charge per session as a currency-tagged string |
| `dailyRate` | string | Daily rate as a currency-tagged string. Often empty. |
| `priceTier` | string | Symbolic price tier — `$`, `$$`, `$$$`, or `$$$$` |
| `portfolioSize` | integer | Number of portfolio pieces on the artist's profile |
| `reviewCount` | integer | Number of reviews backing the rating |
| `reviewAverage` | number | Average review score on a 0–5 scale |
| `bookingsAllowed` | boolean | Whether the artist accepts bookings through Tattoodo |
| `availability` | string | Earliest availability hint (e.g. `Next week`, `3-6 months`) |
| `responseTime` | string | Typical response-time hint (e.g. `2 days`, `a few hours`) |
| `shopName` | string | Name of the studio the artist works out of |
| `address` | string | Street address of the primary studio |
| `city` | string | City of the primary studio |
| `country` | string | ISO 3166-1 alpha-2 country code. Falls back to a timezone lookup when the source field is empty. |
| `timezone` | string | IANA timezone of the primary studio (e.g. `Europe/London`) |
| `phone` | string | Studio phone number, when published |
| `latitude` | number | Primary-studio latitude |
| `longitude` | number | Primary-studio longitude |
| `socialLinks` | string | Comma-separated social-media URLs |
| `instagram` | string | Instagram handle parsed from social links |
| `tiktok` | string | TikTok handle parsed from social links |
| `website` | string | Personal or studio website URL parsed from social links |
| `imageUrl` | string | Profile image URL |
| `profileUrl` | string | Canonical Tattoodo profile URL |
| `scrapedAt` | string | ISO timestamp when the record was scraped |

***

### FAQ

#### How do I scrape tattoo artists from Tattoodo?

Tattoodo Scraper handles it. Set `maxItems`, optionally add a country or style filter, and run. The actor pulls the public partners sitemap, fetches each profile, and writes structured JSON. No login, no proxy, no manual pagination.

#### How much does Tattoodo Scraper cost to run?

Tattoodo Scraper uses pay-per-event pricing. $0.10 per actor start plus $0.001 per record returned. A 1,000-record harvest costs about $1.10, which is less than most people spend on coffee while waiting for slower scrapers to finish.

#### What data can I get from a Tattoodo profile?

Tattoodo Scraper returns about 30 fields per artist — name, studio, address with lat/long, primary and secondary styles, hourly and minimum rates, price tier, ratings, review count, portfolio size, biography, booking availability, response time, social handles when published, and the canonical profile URL. The full schema is documented in the table above.

#### Can I filter by tattoo style or country?

Tattoodo Scraper supports both. Pass an array of country codes (`["US", "GB"]`), style slugs (`["realism", "blackwork"]`), or both. Filters are applied after extraction so style matching covers primary and secondary styles together.

#### Does Tattoodo Scraper need proxies?

Tattoodo Scraper does not need proxies. Tattoodo serves its profile pages from CloudFront with no Cloudflare WAF or CAPTCHA on the artist directory, so the scraper runs cleanly with default headers.

#### How fresh is the data?

Tattoodo Scraper pulls live HTML on every run. The sitemap's `lastmod` updates daily, and profile data — rates, availability, styles — reflects whatever the artist last edited.

***

### Need More Features?

Need additional fields, a different source, or a custom filter? [File an issue](https://console.apify.com/actors/issues) or get in touch.

### Why Use Tattoodo Scraper?

- **Affordable** — $0.001 per record. A 1,600-artist full harvest comes out to under $2.
- **Clean output** — every record carries the same ~30 fields with consistent types, normalized country codes, and a timezone-derived country fallback for entries Tattoodo left blank. Less data cleanup, more analysis.
- **Filter-first design** — country, style, and bookable-only filters apply post-extraction, so a tight filter still returns the slice you asked for without you scraping the whole directory by hand.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

## `countries` (type: `array`):

Filter by ISO 3166-1 alpha-2 country code (e.g. \['US', 'GB', 'DE']). Tattoodo's verified-artist directory skews toward the US, UK, Northern Europe and Latin America. Leave empty to include all countries.

## `styles` (type: `array`):

Filter by primary or secondary tattoo style (case-insensitive substring match against style slugs and names). Examples: 'realism', 'blackwork', 'traditional', 'neo\_traditional', 'fine\_line', 'watercolor', 'japanese', 'dotwork', 'lettering', 'geometric'. Leave empty for all styles.

## `bookableOnly` (type: `boolean`):

When true, only return artists who accept bookings through Tattoodo (`bookings_allowed: true`). Useful for outreach to actively-marketing artists.

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

Maximum number of artist profiles to extract. The verified-artist sitemap has ~1,600 records — set higher for full harvests. Free tester runs are limited to 5 minutes.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "countries": [],
  "styles": [],
  "bookableOnly": false,
  "maxItems": 10
}
```

# 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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "countries": [],
    "styles": [],
    "bookableOnly": false,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/tattoo-piercing-shop-directory-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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "countries": [],
    "styles": [],
    "bookableOnly": False,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/tattoo-piercing-shop-directory-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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "countries": [],
  "styles": [],
  "bookableOnly": false,
  "maxItems": 10
}' |
apify call jungle_synthesizer/tattoo-piercing-shop-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tattoo Artist Directory Scraper - Tattoodo.com",
        "description": "Scrape verified tattoo-artist profiles from Tattoodo.com — the global tattoo directory. Returns artist name, studio location, hourly and minimum rates, primary and secondary styles, ratings, biography, social links, and geo coordinates. Filter by country, style, or booking availability.",
        "version": "1.0",
        "x-build-id": "YfV1cynzFBIaLI4Lz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~tattoo-piercing-shop-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-tattoo-piercing-shop-directory-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/jungle_synthesizer~tattoo-piercing-shop-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-tattoo-piercing-shop-directory-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/jungle_synthesizer~tattoo-piercing-shop-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-tattoo-piercing-shop-directory-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "countries": {
                        "title": "Country Filter",
                        "type": "array",
                        "description": "Filter by ISO 3166-1 alpha-2 country code (e.g. ['US', 'GB', 'DE']). Tattoodo's verified-artist directory skews toward the US, UK, Northern Europe and Latin America. Leave empty to include all countries.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "styles": {
                        "title": "Tattoo Style Filter",
                        "type": "array",
                        "description": "Filter by primary or secondary tattoo style (case-insensitive substring match against style slugs and names). Examples: 'realism', 'blackwork', 'traditional', 'neo_traditional', 'fine_line', 'watercolor', 'japanese', 'dotwork', 'lettering', 'geometric'. Leave empty for all styles.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "bookableOnly": {
                        "title": "Bookable Artists Only",
                        "type": "boolean",
                        "description": "When true, only return artists who accept bookings through Tattoodo (`bookings_allowed: true`). Useful for outreach to actively-marketing artists.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of artist profiles to extract. The verified-artist sitemap has ~1,600 records — set higher for full harvests. Free tester runs are limited to 5 minutes.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
