# Gemini File Search Builder (`yoloshii/gemini-file-search-builder`) Actor

Build Gemini File Search RAG knowledge bases from any website with automatic citations.

- **URL**: https://apify.com/yoloshii/gemini-file-search-builder.md
- **Developed by:** [Yoloshi](https://apify.com/yoloshii) (community)
- **Categories:** AI, Agents, Automation
- **Stats:** 2 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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.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

## Gemini File Search Builder

**Turn any website into an AI-powered knowledge base with Google Gemini. Get unlimited queries with automatic citations.**

### What You Get

Scrape once, query forever. This actor builds permanent Gemini File Search RAG knowledge bases from any website. After initial setup, storage is free and queries use standard Gemini model pricing (subject to Google's rates).

**Perfect for:**
- Creating AI chatbots from documentation
- Building searchable knowledge bases
- Powering RAG applications with website content
- Querying technical docs with natural language

**Key benefits:**
- ✅ **One-time scraping** - Actor fee: $0.0015/page (plus Apify scraper + Gemini costs)
- ✅ **Automatic citations** - Every answer includes sources
- ✅ **Free storage** - File Search stores persist indefinitely at no cost
- ✅ **Cross-platform** - Query from Python, web, or mobile
- ✅ **Challenge compliant** - 100% banned scraper filtering

#### Key Features

- 🧠 **Automatic RAG Pipeline** - Scrape → Clean → Upload to Gemini (all in one run)
- 📚 **Built-in Citations** - Every answer includes source documents
- ♾️ **No per-query fees** - Queries use standard Gemini token pricing (no File Search markup)
- 🎯 **Challenge Compliant** - 100% banned scraper filtering (Instagram, Amazon, Google Maps, etc.)
- 🚀 **Zero Setup** - Just provide URL + Gemini API key
- 💰 **Cost Optimized** - Smart scraper selection based on your budget
- 🎨 **Multiple Output Formats** - Supports Markdown, HTML, and plain text extraction

### Use Cases

- **Documentation Indexing** - Convert technical docs into queryable knowledge bases
- **Research Databases** - Create searchable archives from academic sites
- **Content Libraries** - Index blog posts, articles, tutorials
- **Internal Wikis** - Transform company knowledge bases for AI access

### How It Works

````

Website URL → Scraper Selection → Content Extraction → Document Conversion
↓
Gemini File Search ← Upload Documents
↓
Queryable Knowledge Base (You query it later)

````

1. **Smart Scraper Selection** - Analyzes target and selects optimal Apify scraper
2. **Content Cleaning** - Removes ads, navigation, extracts main content
3. **Document Creation** - Formats as clean text with metadata
4. **Gemini Upload** - Creates File Search Store (persistent, free storage)
5. **Query Guide** - Returns instructions for using your knowledge base

### How to Build a Gemini Knowledge Base (3 Steps)

#### 1. Get API Keys

**Gemini API Key** (required):
- Visit https://aistudio.google.com/apikey
- Create new API key (free tier available)
- ⚠️ **Important:** Use the SAME key you'll use to query the knowledge base later. File Search Stores are tied to the creating API key.

**Apify Token** (required):
- Visit https://console.apify.com/settings/integrations
- Copy your API token

#### 2. Run the Actor

```json
{
  "target": "https://docs.python.org",
  "max_pages": 100,
  "scraper_budget": "optimal",
  "corpus_name": "python-docs",
  "gemini_api_key": "YOUR_GEMINI_KEY",
  "apify_token": "YOUR_APIFY_TOKEN"
}
````

#### 3. Query Your Knowledge Base

After the actor completes, query your knowledge base using:

- **Google AI Studio** (web interface - easiest)
- **Python SDK** (for developers)
- **Gemini mobile apps** (iOS/Android)

**Python example:**

```python
from google import genai
from google.genai import types

client = genai.Client(api_key="YOUR_GEMINI_KEY")

response = client.models.generate_content(
    model='gemini-2.5-flash',  # Or gemini-3-pro, etc.
    contents='Your question here',
    config=types.GenerateContentConfig(
        tools=[types.Tool(
            file_search=types.FileSearch(
                file_search_store_names=["YOUR_STORE_NAME"]
            )
        )]
    )
)

print(response.text)  # Answer with citations
```

**See the query guide in your run's Key-Value Store for complete instructions.**

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `target` | string | ✅ | - | Website URL to scrape and index |
| `max_pages` | integer | | 10 | Maximum pages to scrape (1-2000) |
| `scraper_budget` | string | | "optimal" | Cost strategy: `minimal`, `optimal`, `premium` |
| `corpus_name` | string | ✅ | - | Unique name for your knowledge base |
| `gemini_api_key` | string | ✅ | - | Google Gemini API key |
| `apify_token` | string | ✅ | - | Apify API token |

### Output

```json
{
  "file_search_store_name": "fileSearchStores/pythondocs-abc123",
  "files_indexed": 150,
  "total_size_mb": 2.5,
  "estimated_tokens": 125000,
  "indexing_cost_usd": 0.0188,
  "storage_type": "File Search Store",
  "storage_persistence": "Indefinite (free)",
  "query_cost_estimate": "$0.001 per query",
  "query_guide_url": "https://docs.google.com/..."
}
```

### How Much Does It Cost?

**IMPORTANT:** The total cost includes THREE separate components billed by different services:

#### 1. Actor Fees (Charged by This Actor)

This Actor uses **pay-per-page pricing**:

- **Actor start**: $0.02 per run (one-time)
- **Page processed**: $0.0015 per page (base price)

**Store Discount Tiers** - Your Apify subscription plan determines automatic discounts:

| Plan | Monthly Cost | Discount | Actor Price/Page | Actor Cost (100 Pages) |
|------|--------------|----------|------------------|------------------------|
| **Free** | $0 | 0% | $0.0015 | **$0.17** |
| **Starter** | $39 | 10% (BRONZE) | $0.00135 | **$0.155** |
| **Scale** | $199 | 20% (SILVER) | $0.0012 | **$0.14** |
| **Business** | $999 | 30% (GOLD) | $0.00105 | **$0.125** |

💰 **Upgrade your Apify plan to save up to 30% on actor fees!**

#### 2. Apify Scraper Costs (Charged by Apify Platform)

The actor uses Apify scrapers to extract content. **You pay Apify separately** for:

- Scraper compute time (varies by scraper and site complexity)
- Typical cost: **$0.001-0.01 per page** (depends on scraper\_budget setting)
- Billed from your Apify platform credits

**Example for 100 pages:**

- Minimal budget: ~$0.10 (simple HTML scrapers)
- Optimal budget: ~$0.50 (balanced performance)
- Premium budget: ~$1.00+ (advanced AI scrapers)

#### 3. Gemini API Costs (Charged by Google)

Google charges for File Search usage as follows:

**One-time indexing costs:**

- **Embeddings**: $0.15 per 1M tokens (when uploading documents)
- Typical 100-page site: ~$0.01-0.10 in indexing fees

**Storage costs:**

- **FREE** (indefinite, no ongoing fees)

**Query costs (ongoing):**

- **Retrieved context**: Charged as standard input tokens to the LLM
- **LLM inference**: Standard Gemini model pricing (varies by model: Gemini 3 Pro, Gemini 2.5 Flash, etc.)
- **No File Search markup**: Google charges only standard model rates

**Query costs are entirely determined by Google's pricing** at the time you query.
The actor has no control over these costs.

See [Gemini pricing](https://ai.google.dev/gemini-api/docs/pricing) for current rates.

#### Total Cost Example (100 Pages)

| Component | Cost (Typical) |
|-----------|----------------|
| Actor fee (FREE tier) | $0.17 |
| Apify scraper (optimal) | ~$0.50 |
| Gemini indexing | ~$0.05 |
| **TOTAL** | **~$0.72** |

**After indexing:** Storage is free. Query costs subject to Google Gemini's pricing (varies by model).

#### What You DON'T Pay to This Actor

✅ **Apify scraper costs** - Billed separately by Apify platform (from your credits)
✅ **Gemini API costs** - Billed separately by Google (from your Gemini API key)
✅ **Pass-through fees** - No markup; you pay Apify and Google directly

#### Comparison

- **10x cheaper** than premium AI collectors ($0.0025 vs $0.25/page)
- **Gemini-optimized** vs generic scrapers
- **Transparent billing** - Only successful pages charged

### Challenge Compliance

**Apify $1M Challenge - Fully Compliant**

✅ **100% Banned Scraper Filter**

- Social media: Instagram, Facebook, TikTok, LinkedIn, Twitter, YouTube
- E-commerce: Amazon
- Search engines: Google Maps, Google Search, Google Trends
- B2B platforms: Apollo

✅ **Quality Assurance**

- 49/49 unit tests passing
- Production-tested on real websites
- Automatic fallback system for reliability

### FAQ

**Q: How long does the knowledge base persist?**
A: Indefinitely (until manually deleted). No storage expiration or fees.

**Q: Can I update the knowledge base later?**
A: Yes! Upload additional documents to the same File Search Store.

**Q: What's the maximum site size?**
A: Up to 2,000 pages (configurable), ~2GB total content.

**Q: Do I need a Google Cloud account?**
A: No! Just a Gemini API key from aistudio.google.com (free tier available).

**Q: Can I use a different API key to query the knowledge base?**
A: No. File Search Stores are tied to the API key that created them. You must use the SAME Gemini API key for both creating and querying the knowledge base. This ensures your data remains private and accessible only to you.

**Q: How accurate are the citations?**
A: Gemini File Search automatically cites source documents with chunk-level precision.

**Q: Is web scraping legal?**
A: Web scraping is generally legal for publicly available, non-personal data. Always respect robots.txt and website terms of service. For personal data, ensure GDPR compliance. Consult legal counsel if unsure. Learn more: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

### Integrations

This Actor works seamlessly with Apify's platform integrations:

- **Make, Zapier** - Automate workflows with no-code tools
- **Webhooks** - Trigger actions when knowledge base creation completes
- **API Access** - Control programmatically via Python/JavaScript SDKs
- **Scheduled Runs** - Automatically update knowledge bases on schedule

All Apify actors support these integrations out of the box. See [Apify integrations](https://docs.apify.com/platform/integrations) for setup guides.

### Using with AI Agents

This Actor is compatible with Model Context Protocol (MCP) and can be used with AI agents:

- **Claude Desktop** - Use via Apify MCP server
- **LibreChat** - Integrate into chat workflows
- **Custom MCP clients** - Programmatic access

AI agents can trigger this Actor automatically based on user queries. See the [MCP documentation](https://docs.apify.com/platform/integrations/mcp) for setup instructions.

### Support

**Need help?**

- Use the **Issues** tab above to report problems or request features
- Check the **FAQ** section for common questions
- Contact via Apify messaging for urgent issues

**Built for the Apify $1M Challenge** (November 2025 - January 2026)

# Actor input Schema

## `target` (type: `string`):

Website to scrape and index

## `max_pages` (type: `integer`):

Maximum number of pages to scrape and index

## `scraper_budget` (type: `string`):

Cost optimization strategy

## `corpus_name` (type: `string`):

Unique name for your knowledge base (e.g., 'python-docs', 'company-wiki'). Helps you identify it when querying or managing multiple stores.

## `gemini_api_key` (type: `string`):

Your Google Gemini API key (from aistudio.google.com). IMPORTANT: Use the SAME key you'll use to query the knowledge base later. File Search Stores are tied to the API key that created them.

## `apify_token` (type: `string`):

Your Apify token (from console.apify.com/settings/integrations)

## Actor input object example

```json
{
  "target": "https://docs.react.dev",
  "max_pages": 10,
  "scraper_budget": "optimal",
  "corpus_name": "my-documentation"
}
```

# Actor output Schema

## `knowledge_base` (type: `string`):

Gemini File Search Store metadata and access information

## `query_guide` (type: `string`):

Instructions for querying your knowledge base

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("yoloshii/gemini-file-search-builder").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("yoloshii/gemini-file-search-builder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call yoloshii/gemini-file-search-builder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=yoloshii/gemini-file-search-builder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gemini File Search Builder",
        "description": "Build Gemini File Search RAG knowledge bases from any website with automatic citations.",
        "version": "0.0",
        "x-build-id": "C89IiDpzeUrTorMk3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/yoloshii~gemini-file-search-builder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-yoloshii-gemini-file-search-builder",
                "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/yoloshii~gemini-file-search-builder/runs": {
            "post": {
                "operationId": "runs-sync-yoloshii-gemini-file-search-builder",
                "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/yoloshii~gemini-file-search-builder/run-sync": {
            "post": {
                "operationId": "run-sync-yoloshii-gemini-file-search-builder",
                "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": [
                    "target",
                    "corpus_name",
                    "gemini_api_key",
                    "apify_token"
                ],
                "properties": {
                    "target": {
                        "title": "Target URL",
                        "type": "string",
                        "description": "Website to scrape and index"
                    },
                    "max_pages": {
                        "title": "Maximum Pages",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of pages to scrape and index",
                        "default": 10
                    },
                    "scraper_budget": {
                        "title": "Scraper Budget",
                        "enum": [
                            "minimal",
                            "optimal",
                            "premium"
                        ],
                        "type": "string",
                        "description": "Cost optimization strategy",
                        "default": "optimal"
                    },
                    "corpus_name": {
                        "title": "Knowledge Base Name",
                        "type": "string",
                        "description": "Unique name for your knowledge base (e.g., 'python-docs', 'company-wiki'). Helps you identify it when querying or managing multiple stores."
                    },
                    "gemini_api_key": {
                        "title": "Gemini API Key",
                        "type": "string",
                        "description": "Your Google Gemini API key (from aistudio.google.com). IMPORTANT: Use the SAME key you'll use to query the knowledge base later. File Search Stores are tied to the API key that created them."
                    },
                    "apify_token": {
                        "title": "Apify API Token",
                        "type": "string",
                        "description": "Your Apify token (from console.apify.com/settings/integrations)"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```