# Fiverr Gigs & Seller Scraper (`fetch_cat/fiverr-gigs-seller-scraper`) Actor

Scrape public Fiverr gig search listings with seller cards, prices, ratings, reviews, images, ranking, and source query metadata.

- **URL**: https://apify.com/fetch\_cat/fiverr-gigs-seller-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $221.92 / 1,000 fiverr gig listing saveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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/docs.md):

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

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

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

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

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

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

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

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

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


# README

## Fiverr Gigs & Seller Scraper

Scrape public Fiverr search results and export gig listing data with seller cards, prices, ratings, review counts, images, ranking, and source query metadata.

Use this Actor for marketplace research, service-price monitoring, freelancer/vendor discovery, category tracking, and repeatable Fiverr data exports to CSV, JSON, Excel, API, or automation workflows.

### What data you get

Fiverr search pages are useful for pricing research, vendor shortlists, and marketplace monitoring, but copying listings by hand is slow and inconsistent. This Actor turns public Fiverr search results into a clean dataset with gig URLs, seller names, prices, ratings, reviews, images, and search-rank context.

### What it does

- **Search Fiverr by keyword** such as `logo design`, `shopify developer`, or `wordpress speed optimization`.
- **Process public Fiverr search/category URLs** when you already have a filtered Fiverr URL.
- **Save one row per unique gig listing** with seller-card and pricing fields visible on public search pages.
- **Deduplicate by gig URL** across multiple keywords or pages.
- **Report blocked/challenge pages clearly** instead of charging for unusable pages.

### Use cases

- **Marketplace researchers** compare Fiverr categories, starting prices, ratings, and seller levels.
- **Agencies and buyers** build repeatable shortlists for service niches such as logo design or Shopify development.
- **Growth and SEO teams** monitor marketplace supply and competitor positioning over time.
- **Data teams** export public Fiverr listings to CSV, JSON, Excel, API, or downstream workflows.

### Ready-to-run examples

- [Fiverr logo design gigs](https://apify.com/fetch_cat/fiverr-gigs-seller-scraper/examples/fiverr-logo-design-gigs) — small smoke test for `logo design` with `maxItems: 10`.
- [Fiverr SEO gigs](https://apify.com/fetch_cat/fiverr-gigs-seller-scraper/examples/fiverr-seo-gigs) — compare public SEO service listings.
- [Fiverr URL sample](https://apify.com/fetch_cat/fiverr-gigs-seller-scraper/examples/fiverr-url-sample) — scrape a public Fiverr search URL through `startUrls`.

### Input recipes

- **Small smoke test**: `queries: ["logo design"]`, `maxItems: 10`, `maxPagesPerQuery: 1`.
- **Buyer/vendor comparison**: `queries: ["shopify developer", "wordpress speed optimization"]`, `maxItems: 100`.
- **Search URL monitoring**: paste one public Fiverr search URL in `startUrls`, set `maxItems`, and schedule repeat runs.

US residential proxy is recommended for Fiverr. During development, the `shopify developer` query was blocked on generic residential but succeeded with US residential.

### Example input

```json
{
  "queries": ["logo design", "shopify developer"],
  "maxItems": 25,
  "maxPagesPerQuery": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
````

### Example output

```json
{
  "gigId": "aHR0cHM6Ly93d3cuZml2ZXJy",
  "gigUrl": "https://www.fiverr.com/remonisco/design-a-modern-minimalist-logo",
  "title": "design a modern minimalist logo",
  "sellerName": "remonisco",
  "sellerUrl": "https://www.fiverr.com/remonisco",
  "sellerLevel": "Level 2",
  "priceFrom": 20,
  "priceCurrency": "$",
  "priceRaw": "From $20",
  "rating": 4.9,
  "reviewCount": 1200,
  "deliveryTime": "3 days",
  "imageUrl": "https://fiverr-res.cloudinary.com/...jpg",
  "rank": 1,
  "sourceQuery": "logo design",
  "sourceUrl": "https://www.fiverr.com/search/gigs?query=logo+design",
  "page": 1,
  "scrapedAt": "2026-07-17T08:22:51.000Z",
  "diagnostics": { "status": 200, "title": "Logo Design Services - Design Your Own Logo | Fiverr" }
}
```

### Input settings

| Setting | JSON key | Description | Default |
| --- | --- | --- | --- |
| Search keywords | `queries` | Fiverr search phrases to scrape. | `logo design`, `shopify developer` |
| Search/category URLs | `startUrls` | Optional public Fiverr search or category URLs. | none |
| Maximum gigs | `maxItems` | Total unique gig listings to save. | `10` |
| Pages per query | `maxPagesPerQuery` | Fiverr result pages to visit for each keyword. | `1` |
| Proxy | `proxyConfiguration` | Apify Proxy settings; US residential recommended. | Residential |

### Output fields

| Field | Description |
| --- | --- |
| `gigId`, `gigUrl`, `title` | Stable gig identifier, canonical gig URL, and listing title. |
| `sellerName`, `sellerUrl`, `sellerLevel` | Public seller card fields. |
| `priceFrom`, `priceCurrency`, `priceRaw` | Parsed starting price plus original price text. |
| `rating`, `reviewCount`, `deliveryTime` | Public quality and delivery signals when present. |
| `imageUrl` | Listing thumbnail URL. |
| `rank`, `sourceQuery`, `sourceUrl`, `page` | Search context and page ranking. |
| `scrapedAt`, `diagnostics` | Run timestamp and page status metadata. |

### Pricing

This Actor uses pay-per-event pricing. A small start event is charged once per run, and the primary item event is charged only when a unique Fiverr gig listing is saved.

| Event | Free | Bronze | Silver | Gold | Platinum | Diamond | Charged when |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | --- |
| Run start | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | Once when a run starts. |
| Fiverr gig listing saved | $0.42535 | $0.36987 | $0.28850 | $0.22192 | $0.14795 | $0.10356 | Each unique gig listing is saved. |

### Tips and limits

- Start with `maxItems: 10` to verify output for your Fiverr niche.
- Use focused keywords. Very broad searches may produce repeated or sponsored cards.
- Fiverr can show anti-bot challenges. If you receive blocked diagnostics, use US residential proxy and retry with a smaller input.
- This Actor extracts public listing cards only. Gig details, reviews, and full seller profiles are intentionally deferred.
- Do not use this Actor for spam, contact harvesting, or private account data.

### API usage

**Node.js**

```js
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/fiverr-gigs-seller-scraper").call({
  queries: ["logo design"],
  maxItems: 10,
  proxyConfiguration: { useApifyProxy: true, apifyProxyGroups: ["RESIDENTIAL"], apifyProxyCountry: "US" }
});
console.log(run.defaultDatasetId);
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetch_cat/fiverr-gigs-seller-scraper").call(run_input={
    "queries": ["logo design"],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
})
print(run["defaultDatasetId"])
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~fiverr-gigs-seller-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["logo design"],"maxItems":10}'
```

### MCP and AI agents

Use this Actor through the official Apify MCP Server.

**MCP server configuration**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/fiverr-gigs-seller-scraper"
    }
  }
}
```

**Claude CLI**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/fiverr-gigs-seller-scraper"
```

**Example prompts**

- "Run the Fiverr Gigs & Seller Scraper for logo design and summarize the average starting price."
- "Collect 20 Shopify developer gigs from Fiverr and list sellers with rating and review counts."
- "Compare public Fiverr listings for wordpress speed optimization versus shopify developer."

### Related actors

- [Google Shopping Results Scraper](https://apify.com/fetch_cat/google-shopping-results-scraper)
- [Pinterest Profile Scraper](https://apify.com/fetch_cat/pinterest-profile-scraper)
- [Trip.com Reviews Scraper](https://apify.com/fetch_cat/trip-com-reviews-scraper)

### FAQ

**Does this scrape private Fiverr data?** No. It extracts public listing-card data visible on Fiverr search/category pages without login.

**Why should I use a residential proxy?** Fiverr can return edge challenges to datacenter traffic. US residential proxy is the safest default validated during development.

**Can it scrape gig reviews or full seller profiles?** Not in V1. Reviews, packages, and deep seller profile pages are deferred until listing-route reliability is proven.

**What happens if Fiverr shows a challenge page?** The Actor retries with fresh proxy sessions, records diagnostics, and fails only if every attempt produces a zero-item challenge-only run.

### Support

Questions, bugs, or feature requests? Open an issue on the Actor page in Apify Console and include:

- **Input JSON**: the exact `queries`, `startUrls`, limits, and proxy settings.
- **Expected output**: the Fiverr listings or fields you expected to receive.
- **Actual output**: dataset item count, missing fields, error message, or diagnostic snippet.
- **Reproducible public URL**: a Fiverr search/category URL when possible, plus the Apify run ID.

# Actor input Schema

## `queries` (type: `array`):

Fiverr search phrases such as logo design or Shopify developer.

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

Optional public Fiverr search or category URLs to process.

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

Maximum number of unique Fiverr gig listings to save.

## `maxPagesPerQuery` (type: `integer`):

How many Fiverr result pages to visit per keyword.

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

Apify Proxy configuration. Residential proxy is recommended for Fiverr runtime verification.

## Actor input object example

```json
{
  "queries": [
    "logo design",
    "shopify developer"
  ],
  "startUrls": [],
  "maxItems": 10,
  "maxPagesPerQuery": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "logo design",
        "shopify developer"
    ],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/fiverr-gigs-seller-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 = {
    "queries": [
        "logo design",
        "shopify developer",
    ],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/fiverr-gigs-seller-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 '{
  "queries": [
    "logo design",
    "shopify developer"
  ],
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call fetch_cat/fiverr-gigs-seller-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fiverr Gigs & Seller Scraper",
        "description": "Scrape public Fiverr gig search listings with seller cards, prices, ratings, reviews, images, ranking, and source query metadata.",
        "version": "0.1",
        "x-build-id": "RP17jHUyVAwYEa9HN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~fiverr-gigs-seller-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-fiverr-gigs-seller-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/fetch_cat~fiverr-gigs-seller-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-fiverr-gigs-seller-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/fetch_cat~fiverr-gigs-seller-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-fiverr-gigs-seller-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": {
                    "queries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Fiverr search phrases such as logo design or Shopify developer.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Fiverr search/category URLs",
                        "type": "array",
                        "description": "Optional public Fiverr search or category URLs to process.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum gigs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of unique Fiverr gig listings to save.",
                        "default": 10
                    },
                    "maxPagesPerQuery": {
                        "title": "Maximum pages per query",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many Fiverr result pages to visit per keyword.",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy configuration. Residential proxy is recommended for Fiverr runtime verification."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
