# Fiverr Gigs Scraper (`junipr/fiverr-scraper`) Actor

Scrape Fiverr freelancer gig listings including titles, prices, ratings, reviews, delivery times, and seller information. Filter by category, search query, or seller level.

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

## Pricing

$2.60 / 1,000 gig scrapeds

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Fiverr Gigs Scraper

Extract Fiverr gig data at scale — pricing tiers, seller ratings, delivery times, order counts, reviews, and FAQs. The only Fiverr scraper that actually works: built to replace the broken 1.0-star actor that left 500+ users without a solution.

### What is Fiverr Gigs Scraper?

Fiverr is home to 4 million+ active buyers and hundreds of thousands of freelance gigs across design, development, writing, marketing, and more. This actor scrapes Fiverr gig listings in bulk, giving you structured data for competitive pricing analysis, lead generation, freelance market research, and gig economy studies.

Unlike other Fiverr scrapers that crash on first run or miss critical fields, this actor extracts complete three-tier pricing (Basic, Standard, Premium), full seller profile data, and gig metadata — reliably, at scale, with Cloudflare bypass built in.

### Key Features

- **Three-tier pricing extraction** — Basic, Standard, and Premium packages with price, delivery days, revisions, and feature lists
- **Complete seller profiles** — level (New, Level 1, Level 2, Top Rated, Pro), rating, review count, response time, member since, country, languages
- **Pro and Top Rated badge detection** — `isPro` and `level` flags for accurate seller filtering
- **Category and keyword search** — search by keyword, category slug, or subcategory slug with full filter support
- **Seller-level filtering** — narrow results to specific seller tiers (e.g. Top Rated + Pro only)
- **Price range filtering** — set minimum and maximum price bounds
- **Delivery time filtering** — filter by 1-day, 3-day, or 7-day delivery options
- **Review extraction** — up to 10 sample reviews per gig with reviewer name, rating, text, and date
- **FAQ extraction** — full FAQ section from each gig page
- **Direct URL mode** — scrape specific gig URLs by providing a list directly
- **Batch search** — run up to 50 search terms in a single actor run
- **Cloudflare bypass** — uses Playwright with realistic browser fingerprinting to handle Fiverr's Cloudflare protection

### What Data Can You Extract?

| Field | Description |
|-------|-------------|
| `gigId` | Fiverr gig slug identifier |
| `url` | Full URL to the gig page |
| `title` | Complete gig title |
| `description` | Plain text gig description |
| `seller.username` | Seller's Fiverr username |
| `seller.displayName` | Seller's display name |
| `seller.level` | Seller level: new, level_one, level_two, top_rated, pro |
| `seller.isPro` | Whether the seller has Fiverr Pro verification |
| `seller.rating` | Seller rating (1–5 scale) |
| `seller.reviewCount` | Total review count |
| `seller.responseTime` | Typical response time |
| `seller.country` | Seller's country code |
| `seller.languages` | Languages the seller speaks |
| `seller.memberSince` | When the seller joined Fiverr |
| `pricing.basic` | Basic tier: price, delivery days, revisions, features |
| `pricing.standard` | Standard tier (null if not offered) |
| `pricing.premium` | Premium tier (null if not offered) |
| `category` | Main category (e.g. Graphics & Design) |
| `subcategory` | Subcategory (e.g. Logo Design) |
| `tags` | Gig tags and keywords |
| `images` | Portfolio image URLs |
| `hasVideo` | Whether gig includes a video |
| `faq` | FAQ question-and-answer pairs |
| `reviews` | Sample reviews (up to 10) |
| `orderCount` | Total orders completed |
| `scrapedAt` | Extraction timestamp |

### Proxy Requirements

This actor requires **residential proxy** to access Fiverr, which blocks datacenter IP addresses.

- **Apify paid plans**: Residential proxy is included. The actor uses it by default.
- **Apify free plan**: Free plan does not include residential proxy. You can provide your own residential proxy URL in the proxy configuration, or the actor will attempt to run without proxy (results may be empty or blocked).
- **Without residential proxy**: The actor will still run but may return zero results due to IP blocking by Fiverr.

### How to Use

#### Freelance Market Research

Search for a service category and analyze pricing across hundreds of gigs to understand what the market charges, what features sellers include, and which delivery times are most common:

```json
{
  "searchTerms": ["seo optimization", "content writing"],
  "maxGigs": 200,
  "sortBy": "best_selling"
}
````

#### Competitive Intelligence for Sellers

Find the top-performing gigs in your niche and analyze what makes them successful — their pricing tiers, descriptions, tags, and seller levels:

```json
{
  "searchTerms": ["wordpress website development"],
  "maxGigs": 100,
  "sellerLevel": ["top_rated", "pro"],
  "sortBy": "best_selling",
  "includeFaq": true
}
```

#### Lead Generation

Identify active freelancers offering specific services. Filter by seller level, country, and response time to find high-quality leads for partnership outreach or talent acquisition:

```json
{
  "searchTerms": ["react developer"],
  "sellerLevel": ["level_two", "top_rated"],
  "sellerCountry": "US",
  "priceMin": 100,
  "sortBy": "best_selling"
}
```

#### Direct Gig Scraping

Scrape a specific list of gig URLs to monitor competitor pricing changes or build a dataset of known gigs:

```json
{
  "gigUrls": [
    "https://www.fiverr.com/designpro99/design-a-modern-minimalist-logo",
    "https://www.fiverr.com/webdev_expert/build-a-wordpress-website"
  ],
  "includeReviews": true
}
```

### Pricing

**$2.60 per 1,000 gigs** extracted. Pay only for results — no charge for paused gigs, deleted gigs, zero-result searches, or blocked pages. This is a Pay-Per-Event actor: you are billed only for each gig successfully pushed to the dataset.

Pricing includes all platform compute costs — no hidden fees.

A typical run of 100 gigs costs $0.25. A batch run of 1,000 gigs costs $2.50.

### Input and Output Examples

**Minimal input (zero-config):**

```json
{}
```

Scrapes 100 most relevant gigs for "logo design" with pricing tiers and FAQ.

**Full input example:**

```json
{
  "searchTerms": ["logo design", "brand identity"],
  "maxGigs": 500,
  "sellerLevel": ["top_rated", "pro"],
  "priceMin": 25,
  "priceMax": 500,
  "sortBy": "best_selling",
  "includeReviews": true,
  "includeFaq": true
}
```

**Output example (single gig):**

```json
{
  "gigId": "i-will-design-a-modern-minimalist-logo",
  "url": "https://www.fiverr.com/designpro99/i-will-design-a-modern-minimalist-logo",
  "title": "I will design a modern minimalist logo for your business",
  "seller": {
    "username": "designpro99",
    "level": "top_rated",
    "isPro": false,
    "rating": 4.9,
    "reviewCount": 2340
  },
  "pricing": {
    "basic": { "price": 25, "deliveryDays": 3, "revisions": 1 },
    "standard": { "price": 50, "deliveryDays": 3, "revisions": 3 },
    "premium": { "price": 120, "deliveryDays": 5, "revisions": -1 }
  },
  "category": "Graphics & Design",
  "subcategory": "Logo Design",
  "orderCount": 5678,
  "scrapedAt": "2026-03-11T12:00:00.000Z"
}
```

### Related Scrapers by Junipr

- [Glassdoor Jobs Scraper](https://apify.com/junipr/glassdoor-scraper) — Extract job postings with salary ranges, company ratings, and interview insights
- [Indeed Job Scraper](https://apify.com/junipr/indeed-scraper) — Scrape Indeed job listings with full job descriptions and employer details

***

#### How much does it cost to scrape Fiverr?

$2.60 per 1,000 gigs. A 100-gig run costs $0.26. There are no monthly fees — you only pay for the gigs you successfully extract.

#### Can I extract all three pricing tiers?

Yes. The actor extracts Basic, Standard, and Premium tiers from every gig that offers them — including price, delivery days, revision count, and feature list. Gigs that only offer a Basic tier will have `standard: null` and `premium: null`.

#### Can I filter by seller level (Pro, Top Rated)?

Yes. Set `sellerLevel` to an array of values: `"new"`, `"level_one"`, `"level_two"`, `"top_rated"`, or `"pro"`. You can combine multiple levels in one run.

#### Does it extract seller reviews?

Yes, when `includeReviews` is set to `true`. Up to 10 reviews per gig are extracted, including reviewer name, rating, text, and date.

#### Can I search by category and subcategory?

Yes. Use the `category` and `subcategory` fields with Fiverr's category slugs (e.g. `"graphics-design"` and `"logo-design"`). You can combine category filtering with keyword search terms.

#### Is scraping Fiverr legal?

Fiverr's Terms of Service prohibit automated scraping. However, all gig pages are publicly visible with no login required, and this actor only extracts publicly available data. Users are responsible for ensuring their use of scraped data complies with applicable laws and Fiverr's Terms of Service. This actor is intended for market research and competitive analysis purposes.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search for gigs on Fiverr (e.g. "logo design", "wordpress development"). Up to 50 terms, up to 200 characters each.

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

Direct Fiverr gig URLs to scrape (e.g. "https://www.fiverr.com/username/i-will-design-a-logo"). Leave empty to use search terms instead.

## `maxGigs` (type: `integer`):

Maximum number of gigs to extract per search term.

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

Filter results by Fiverr category slug (e.g. "graphics-design", "programming-tech"). Leave empty for all categories.

## `subcategory` (type: `string`):

Filter results by Fiverr subcategory slug (e.g. "logo-design", "wordpress"). Leave empty for all subcategories.

## `sellerLevel` (type: `array`):

Filter by seller level. Leave empty to include all levels.

## `priceMin` (type: `integer`):

Minimum gig price in USD. Fiverr minimum is $5. Leave empty for no minimum.

## `priceMax` (type: `integer`):

Maximum gig price in USD. Must be greater than minimum price. Leave empty for no maximum.

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

Filter by maximum delivery time.

## `sellerLanguage` (type: `string`):

Filter by seller language (ISO 639-1 code, e.g. "en", "es", "fr"). Leave empty to include all languages.

## `sellerCountry` (type: `string`):

Filter by seller country (ISO 3166-1 alpha-2, e.g. "US", "GB", "IN"). Leave empty to include all countries.

## `onlineOnly` (type: `boolean`):

Only return gigs from sellers who are currently online.

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

Sort order for search results.

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

Extract up to 10 sample reviews per gig. Adds extra page loading time.

## `includeFaq` (type: `boolean`):

Extract the gig FAQ section (questions and answers).

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

Residential proxy is required — Fiverr blocks datacenter IP addresses with 403 errors. Apify paid plans include residential proxy. Free-plan users: provide your own residential proxy URL.

## Actor input object example

```json
{
  "searchTerms": [
    "logo design"
  ],
  "gigUrls": [],
  "maxGigs": 100,
  "category": "",
  "subcategory": "",
  "sellerLevel": [],
  "deliveryTime": "all",
  "sellerLanguage": "",
  "sellerCountry": "",
  "onlineOnly": false,
  "sortBy": "relevance",
  "includeReviews": false,
  "includeFaq": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Scraped Fiverr gig listings with full pricing tiers, seller details, and metadata.

# 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 = {
    "searchTerms": [
        "logo design"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("junipr/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 = { "searchTerms": ["logo design"] }

# Run the Actor and wait for it to finish
run = client.actor("junipr/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 '{
  "searchTerms": [
    "logo design"
  ]
}' |
apify call junipr/fiverr-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fiverr Gigs Scraper",
        "description": "Scrape Fiverr freelancer gig listings including titles, prices, ratings, reviews, delivery times, and seller information. Filter by category, search query, or seller level.",
        "version": "1.0",
        "x-build-id": "MTg6Vav9WbKRfJtlo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/junipr~fiverr-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-junipr-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/junipr~fiverr-scraper/runs": {
            "post": {
                "operationId": "runs-sync-junipr-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/junipr~fiverr-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-junipr-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",
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Keywords to search for gigs on Fiverr (e.g. \"logo design\", \"wordpress development\"). Up to 50 terms, up to 200 characters each.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "logo design"
                        ]
                    },
                    "gigUrls": {
                        "title": "Direct Gig URLs",
                        "type": "array",
                        "description": "Direct Fiverr gig URLs to scrape (e.g. \"https://www.fiverr.com/username/i-will-design-a-logo\"). Leave empty to use search terms instead.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxGigs": {
                        "title": "Max Gigs",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of gigs to extract per search term.",
                        "default": 100
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Filter results by Fiverr category slug (e.g. \"graphics-design\", \"programming-tech\"). Leave empty for all categories.",
                        "default": ""
                    },
                    "subcategory": {
                        "title": "Subcategory",
                        "type": "string",
                        "description": "Filter results by Fiverr subcategory slug (e.g. \"logo-design\", \"wordpress\"). Leave empty for all subcategories.",
                        "default": ""
                    },
                    "sellerLevel": {
                        "title": "Seller Level",
                        "type": "array",
                        "description": "Filter by seller level. Leave empty to include all levels.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "priceMin": {
                        "title": "Minimum Price (USD)",
                        "minimum": 5,
                        "type": "integer",
                        "description": "Minimum gig price in USD. Fiverr minimum is $5. Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Maximum Price (USD)",
                        "minimum": 5,
                        "type": "integer",
                        "description": "Maximum gig price in USD. Must be greater than minimum price. Leave empty for no maximum."
                    },
                    "deliveryTime": {
                        "title": "Delivery Time",
                        "enum": [
                            "all",
                            "1day",
                            "3days",
                            "7days",
                            "anytime"
                        ],
                        "type": "string",
                        "description": "Filter by maximum delivery time.",
                        "default": "all"
                    },
                    "sellerLanguage": {
                        "title": "Seller Language",
                        "type": "string",
                        "description": "Filter by seller language (ISO 639-1 code, e.g. \"en\", \"es\", \"fr\"). Leave empty to include all languages.",
                        "default": ""
                    },
                    "sellerCountry": {
                        "title": "Seller Country",
                        "type": "string",
                        "description": "Filter by seller country (ISO 3166-1 alpha-2, e.g. \"US\", \"GB\", \"IN\"). Leave empty to include all countries.",
                        "default": ""
                    },
                    "onlineOnly": {
                        "title": "Online Sellers Only",
                        "type": "boolean",
                        "description": "Only return gigs from sellers who are currently online.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "best_selling",
                            "newest",
                            "price_asc",
                            "price_desc"
                        ],
                        "type": "string",
                        "description": "Sort order for search results.",
                        "default": "relevance"
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Extract up to 10 sample reviews per gig. Adds extra page loading time.",
                        "default": false
                    },
                    "includeFaq": {
                        "title": "Include FAQ",
                        "type": "boolean",
                        "description": "Extract the gig FAQ section (questions and answers).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxy is required — Fiverr blocks datacenter IP addresses with 403 errors. Apify paid plans include residential proxy. Free-plan users: provide your own residential proxy URL.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
