# Fiverr Scraper (`labrat011/fiverr-scraper`) Actor

Scrape Fiverr gigs, seller profiles, and search results at scale. Search by keyword, extract full gig details (description, packages, FAQ, reviews), or scrape seller profiles. Playwright + residential proxies for PerimeterX bypass. Batch search, no API keys. Pay-per-event from $2.00/1k.

- **URL**: https://apify.com/labrat011/fiverr-scraper.md
- **Developed by:** [mick\_](https://apify.com/labrat011) (community)
- **Categories:** Automation, Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Fiverr Scraper

Scrape Fiverr gigs, search results, and seller profiles at scale. Search by keyword, extract full gig details (packages, FAQ, reviews), or scrape seller profiles. No API keys, no login required.

### What does it do?

The Fiverr Scraper pulls structured data from Fiverr.com — the world's largest freelance marketplace. It handles PerimeterX bot protection using full browser rendering with Playwright and Apify Residential proxies, giving you clean, consistent JSON output ready for market research, competitor analysis, lead generation, or AI pipelines.

**Three modes in one actor:**

- **🔍 Search Gigs** — search by keyword, extract gig cards with pricing, ratings, seller info, and delivery times. Batch search multiple keywords in one run.
- **📄 Gig Details** — provide full gig URLs, get complete details: descriptions, all package tiers with prices, FAQ, seller stats, and optional recent reviews.
- **👤 Seller Profiles** — scrape seller profile pages for stats, badges, bio, languages, and skills.

### 👥 Who Uses This

#### 🏢 Market Researchers and Analysts

You need to understand the freelance marketplace — what services are offered, at what price points, by which sellers. The Fiverr Scraper lets you track pricing trends, identify high-demand categories, and map the competitive landscape across gig economy verticals.

**Track pricing in a category:**

```json
{
    "mode": "search_gigs",
    "searchQueriesList": ["web scraping", "data entry", "logo design", "Python script"],
    "searchSort": "best_selling",
    "maxResults": 500
}
````

Run on a daily or weekly schedule to track category-level pricing shifts over time.

***

#### 💼 Lead Generation and Sales Teams

You want to find Fiverr sellers offering services related to your product or partnership opportunity. Search for relevant keywords, extract seller profiles and contact signals, and build targeted outreach lists.

**Find top sellers in a niche:**

```json
{
    "mode": "search_gigs",
    "searchQuery": "AI chatbot development",
    "searchSort": "recommended",
    "maxResults": 200
}
```

Then switch to seller profile mode to get detailed stats on high-potential leads.

***

#### 🧪 Data Scientists and AI Engineers

You need structured marketplace data for training pricing models, building recommendation systems, or analyzing the gig economy. The consistent JSON output (prices, ratings, descriptions, seller stats) is ready for feature engineering without post-processing.

**Build a pricing dataset:**

```json
{
    "mode": "gig_details",
    "gigUrls": ["https://www.fiverr.com/seller1/gig-name", "https://www.fiverr.com/seller2/another-gig"],
    "includeReviews": true
}
```

***

#### 🛠️ Product and Strategy Teams

You're evaluating entering a new service category on Fiverr. Use the scraper to understand what's already offered, at what price, and by whom. The batch search feature lets you sweep multiple query terms in one run for a comprehensive category analysis.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `search_gigs` | 🎯 Scraping mode |
| `searchQuery` | string | — | 🔍 Single search keyword |
| `searchQueriesList` | array (JSON) | `[]` | 🔍 Batch search queries |
| `searchSort` | select | `recommended` | 🔃 Sort order |
| `minPrice` | number | — | 💰 Minimum price filter |
| `maxPrice` | number | — | 💰 Maximum price filter |
| `deliveryTime` | select | `any` | ⏱️ Delivery time filter |
| `category` | string | — | 📂 Fiverr category filter |
| `gigUrls` | array | `[]` | 📄 Gig URLs for detail mode |
| `sellerUrls` | array | `[]` | 👤 Seller profile URLs |
| `includeReviews` | boolean | `false` | ⭐ Include reviews in gig details |
| `maxResults` | integer | 100 | 🔢 Max results (free: 25 limit) |
| `maxPages` | integer | 10 | 📄 Max search pages per query |
| `proxyConfiguration` | proxy | Residential | 🔒 Proxy config |

### Output

Each record has a `type` field: `gig_search`, `gig_detail`, or `seller_profile`.

#### Search Results (`gig_search`) — $2.00 / 1,000 records

| Field | Type | Description |
|---|---|---|
| `title` | string | Gig title |
| `sellerUsername` | string | Fiverr seller username |
| `sellerLevel` | string | Seller level (Top Rated, Level 2, etc.) |
| `price` | number | Gig starting price in USD |
| `rating` | number | Rating (0–5) |
| `reviewCount` | integer | Number of reviews |
| `deliveryTime` | string | Estimated delivery time |
| `url` | string | Gig permalink |
| `tags` | array | Gig categories/tags |
| `isPro` | boolean | Fiverr Pro verified |
| `isPromoted` | boolean | Promoted listing |
| `searchKeyword` | string | The keyword that produced this result |

#### Gig Details (`gig_detail`) — $3.00 / 1,000 records

All search fields plus:

| Field | Type | Description |
|---|---|---|
| `description` | string | Full gig description |
| `packages` | array | All pricing tiers (name, price, delivery, description) |
| `faq` | array | Gig FAQ items |
| `reviews` | array | Recent reviews (when `includeReviews=true`) |
| `imageUrls` | array | Gallery image URLs |
| `sellerAvatar` | string | Seller profile picture |

#### Seller Profiles (`seller_profile`) — $3.00 / 1,000 records

| Field | Type | Description |
|---|---|---|
| `sellerDisplayName` | string | Seller's display name |
| `sellerDescription` | string | Seller bio |
| `sellerLevel` | string | Fiverr seller level |
| `totalOrders` | integer | Total completed orders |
| `rating` | number | Overall rating |
| `badges` | array | Seller badges |

### Cost

Typical run costs (with Apify Residential proxies):

| Scenario | Results | Est. Cost |
|---|---|---|
| Search "web scraping" (1 page, 24 gigs) | 24 | ~$0.05–0.08 |
| Search 5 keywords, 3 pages each (batch) | 360 | ~$0.70–1.00 |
| Scrape 10 gig details | 10 | ~$0.15–0.25 |
| Scrape 5 seller profiles | 5 | ~$0.10–0.15 |

Pricing is **pay-per-event** — you only pay for results you receive:

- **$2.00 / 1,000 search results** — `per-gig` event charges per gig card scraped
- **$3.00 / 1,000 detail/profile records** — `per-gig-detail` / `per-seller-profile` event
- **$0.02 / run** — `actor-start` event covers minimum compute

### Why This Scraper vs Alternatives

| Feature | **labrat011/fiverr-scraper** | igview-owner/fiverr-scraper | piotrv1001/fiverr-listings-scraper |
|---|---|---|---|
| **Price / 1k** | **$2.00** | $5.00 | $1.50 |
| **Search by keyword** | ✅ | ✅ | ✅ |
| **Batch search** | ✅ (JSON array) | — | — |
| **Gig details (full)** | ✅ | — | — |
| **Seller profiles** | ✅ | — | — |
| **Package tiers** | ✅ | — | — |
| **FAQ extraction** | ✅ | — | — |
| **Reviews** | ✅ (optional) | — | — |
| **Price + delivery filters** | ✅ | — | — |
| **Free tier (25 results)** | ✅ | — | — |
| **MCP-ready** | ✅ | — | — |

### Limitations

- **Fiverr's HTML changes** — if the scraper breaks, file a GitHub issue and we'll patch it
- **Residential proxies required** — datacenter IPs are blocked by PerimeterX
- **Rate limits** — Fiverr may throttle aggressive scraping; reasonable pagination is built in
- **Free tier capped at 25 results** — subscribe for full access

### Changelog

#### v1.0.0 — Initial release

- Search Fiverr gigs by keyword (single or batch)
- Extract full gig details from individual URLs
- Scrape seller profile pages
- PerimeterX/Cloudflare bypass via Playwright + residential proxies
- Batch search with automatic query iteration
- Price and delivery time filters
- Margin circuit breaker to prevent runaway costs

# Actor input Schema

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

What type of Fiverr data to scrape.

## `searchQuery` (type: `string`):

Keyword or phrase to search for on Fiverr. Example: web scraping, logo design, Python script. Use Search Queries List below for batch search.

## `searchQueriesList` (type: `array`):

Run multiple search queries in a single job — results are merged by scrape order. Overrides the single Search Query field when provided. Ideal for market research and competitor analysis. Example: \["logo design", "web scraping", "Python bot"]

## `searchSort` (type: `string`):

How to sort search results.

## `minPrice` (type: `number`):

Minimum gig price filter (optional).

## `maxPrice` (type: `number`):

Maximum gig price filter (optional).

## `deliveryTime` (type: `string`):

Filter by delivery time.

## `category` (type: `string`):

Optional Fiverr category to narrow search (e.g., 'data-entry', 'programming-tech'). Leave empty for all categories.

## `gigUrls` (type: `array`):

Full Fiverr gig URLs to scrape detailed data from (description, packages, FAQ, seller info).

## `sellerUrls` (type: `array`):

Full Fiverr seller profile URLs to scrape. Example: https://www.fiverr.com/sellerusername

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

When scraping gig details, also extract recent reviews (slower, more data).

## `maxResults` (type: `integer`):

Maximum number of results to return. Free users limited to 25 per run.

## `maxPages` (type: `integer`):

Max search result pages to scrape per query (~24 gigs per page).

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

Proxy settings. Fiverr blocks datacenter IPs — residential proxies strongly recommended.

## Actor input object example

```json
{
  "mode": "search_gigs",
  "searchQuery": "web scraping",
  "searchQueriesList": [],
  "searchSort": "recommended",
  "deliveryTime": "any",
  "gigUrls": [
    "https://www.fiverr.com/sellerusername/scrape-web-data"
  ],
  "sellerUrls": [
    "https://www.fiverr.com/sellerusername"
  ],
  "includeReviews": false,
  "maxResults": 100,
  "maxPages": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "searchQuery": "web scraping",
    "searchQueriesList": [],
    "gigUrls": [
        "https://www.fiverr.com/sellerusername/scrape-web-data"
    ],
    "sellerUrls": [
        "https://www.fiverr.com/sellerusername"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("labrat011/fiverr-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 = {
    "searchQuery": "web scraping",
    "searchQueriesList": [],
    "gigUrls": ["https://www.fiverr.com/sellerusername/scrape-web-data"],
    "sellerUrls": ["https://www.fiverr.com/sellerusername"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("labrat011/fiverr-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 '{
  "searchQuery": "web scraping",
  "searchQueriesList": [],
  "gigUrls": [
    "https://www.fiverr.com/sellerusername/scrape-web-data"
  ],
  "sellerUrls": [
    "https://www.fiverr.com/sellerusername"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call labrat011/fiverr-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fiverr Scraper",
        "description": "Scrape Fiverr gigs, seller profiles, and search results at scale. Search by keyword, extract full gig details (description, packages, FAQ, reviews), or scrape seller profiles. Playwright + residential proxies for PerimeterX bypass. Batch search, no API keys. Pay-per-event from $2.00/1k.",
        "version": "1.0",
        "x-build-id": "pmOcpJzqZxhkpPtS4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/labrat011~fiverr-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-labrat011-fiverr-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/labrat011~fiverr-scraper/runs": {
            "post": {
                "operationId": "runs-sync-labrat011-fiverr-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/labrat011~fiverr-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-labrat011-fiverr-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "🎯 Scraping Mode",
                        "enum": [
                            "search_gigs",
                            "gig_details",
                            "seller_profiles"
                        ],
                        "type": "string",
                        "description": "What type of Fiverr data to scrape.",
                        "default": "search_gigs"
                    },
                    "searchQuery": {
                        "title": "🔍 Search Query",
                        "type": "string",
                        "description": "Keyword or phrase to search for on Fiverr. Example: web scraping, logo design, Python script. Use Search Queries List below for batch search."
                    },
                    "searchQueriesList": {
                        "title": "🔍 Search Queries List (Batch Search)",
                        "type": "array",
                        "description": "Run multiple search queries in a single job — results are merged by scrape order. Overrides the single Search Query field when provided. Ideal for market research and competitor analysis. Example: [\"logo design\", \"web scraping\", \"Python bot\"]"
                    },
                    "searchSort": {
                        "title": "🔃 Sort Order",
                        "enum": [
                            "recommended",
                            "best_selling",
                            "newest"
                        ],
                        "type": "string",
                        "description": "How to sort search results.",
                        "default": "recommended"
                    },
                    "minPrice": {
                        "title": "💰 Min Price ($)",
                        "type": "number",
                        "description": "Minimum gig price filter (optional)."
                    },
                    "maxPrice": {
                        "title": "💰 Max Price ($)",
                        "type": "number",
                        "description": "Maximum gig price filter (optional)."
                    },
                    "deliveryTime": {
                        "title": "⏱️ Delivery Time",
                        "enum": [
                            "any",
                            "express_24h",
                            "up_to_3_days",
                            "up_to_7_days",
                            "any_time"
                        ],
                        "type": "string",
                        "description": "Filter by delivery time.",
                        "default": "any"
                    },
                    "category": {
                        "title": "📂 Category",
                        "type": "string",
                        "description": "Optional Fiverr category to narrow search (e.g., 'data-entry', 'programming-tech'). Leave empty for all categories."
                    },
                    "gigUrls": {
                        "title": "📄 Gig URLs",
                        "type": "array",
                        "description": "Full Fiverr gig URLs to scrape detailed data from (description, packages, FAQ, seller info).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellerUrls": {
                        "title": "👤 Seller Profile URLs",
                        "type": "array",
                        "description": "Full Fiverr seller profile URLs to scrape. Example: https://www.fiverr.com/sellerusername",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeReviews": {
                        "title": "⭐ Include Reviews (Gig Details Mode)",
                        "type": "boolean",
                        "description": "When scraping gig details, also extract recent reviews (slower, more data).",
                        "default": false
                    },
                    "maxResults": {
                        "title": "🔢 Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of results to return. Free users limited to 25 per run.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "📄 Max Pages (Search Mode)",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Max search result pages to scrape per query (~24 gigs per page).",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Fiverr blocks datacenter IPs — residential proxies strongly recommended."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```