# Japan Government Data API (`lentic_clockss/japan-government-data-search`) Actor

Search Japanese government procurement, e-Gov open data catalog, and jGrants subsidies via SIP Public Data Gateway API.

- **URL**: https://apify.com/lentic\_clockss/japan-government-data-search.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Lead generation, MCP servers
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Japan Government Data & Procurement Search

Search Japanese government open data, procurement notices, and subsidy programs — all in English — through a single unified API. This Apify Actor queries the SIP Public Data Gateway to retrieve structured results from three major Japanese government data sources: the e-Gov Open Data Catalog, Cabinet Office procurement links, and jGrants subsidy program listings.

Japan's government publishes vast amounts of public data, but accessing it programmatically — especially for non-Japanese speakers — has traditionally been difficult. This Actor removes that barrier by providing a simple keyword-based search interface that returns normalized, English-accessible results from official Japanese government platforms.

### Features

- **Unified multi-source search** — Query up to three Japanese government data sources in a single run with parallel API calls for fast results.
- **Flexible source selection** — Choose any combination of e-Gov open data, Cabinet Office procurement, or jGrants subsidies, or search all three at once.
- **English-accessible** — Results are structured and accessible for international users, researchers, and businesses exploring the Japanese market.
- **Configurable result limits** — Control the number of results per source, up to 200 per source per run.
- **Normalized output** — Every result includes a `_source` field identifying which government data source it came from, making downstream processing straightforward.
- **Parallel execution** — All selected sources are queried concurrently using async HTTP calls, minimizing total run time.

### Data Sources

| Source Key | Product ID | Description |
|---|---|---|
| `egov_catalog` | `jp_egov_opendata_catalog` | e-Gov Open Data Catalog — Japan's central CKAN-based open data portal containing thousands of government datasets across all ministries and agencies. Covers statistics, geospatial data, policy documents, and more. |
| `cao_procurement` | `jp_cao_procurement_links` | Cabinet Office Procurement Links — Official procurement and tender notices published by Japan's Cabinet Office. Includes government contracts, RFPs, and bidding opportunities. |
| `jgrants` | `jp_jgrants_subsidies_search` | jGrants Subsidy Program Search — Japan's digital subsidy platform listing active and past subsidy programs from national and local government agencies. Covers business support, R&D grants, regional development funds, and more. |

### Output Fields

Each result object in the dataset contains:

- `_product_id` — The SIP product identifier (e.g. `jp_egov_opendata_catalog`).
- `_source` — The source label used inside the Actor (`egov_catalog`, `cao_procurement`, `jgrants`).
- `_search_term` — The search term that produced the row.
- `_collected_at` — UTC timestamp when the row was fetched.
- Additional fields vary by source and may include titles, descriptions, URLs, dates, categories, organization names, and other metadata specific to each government platform.

Results are pushed directly to the Apify dataset and can be exported as JSON, CSV, XML, or accessed via the Apify API.

### Input Parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchTerms` | array | Yes | `["Tokyo"]` | Search terms to query across selected Japanese government data sources. Supports English and Japanese keywords. |
| `includeOpenDataPortal` | boolean | No | `true` | Search the e-Gov open data catalog. |
| `includeProcurement` | boolean | No | `true` | Search Cabinet Office procurement links. |
| `includeSubsidies` | boolean | No | `true` | Search jGrants subsidy program listings. |
| `maxResultsPerSource` | integer | No | `50` | Maximum number of results to return per data source. Range: 1–200. |

Legacy compatibility:

- `keyword` is still accepted for older runs
- `sources` is still accepted for older runs
- `maxResults` is still accepted for older runs

### Input Examples

#### Example 1: Search all sources for AI-related government data

```json
{
    "searchTerms": ["artificial intelligence"],
    "includeOpenDataPortal": true,
    "includeProcurement": true,
    "includeSubsidies": true,
    "maxResultsPerSource": 100
}
````

This searches all three Japanese government data sources for anything related to artificial intelligence, returning up to 100 results per source. Useful for researchers tracking Japan's national AI strategy, related procurement, and AI-focused subsidies.

#### Example 2: Find Cabinet Office procurement opportunities for IT services

```json
{
    "searchTerms": ["IT services"],
    "includeOpenDataPortal": false,
    "includeProcurement": true,
    "includeSubsidies": false,
    "maxResultsPerSource": 50
}
```

Targets only the Cabinet Office procurement links to find government tender notices and contract opportunities related to IT services. Ideal for foreign companies looking to bid on Japanese government IT contracts.

#### Example 3: Search jGrants for renewable energy subsidies

```json
{
    "searchTerms": ["renewable energy"],
    "includeOpenDataPortal": false,
    "includeProcurement": false,
    "includeSubsidies": true,
    "maxResultsPerSource": 200
}
```

Searches the jGrants subsidy platform for programs related to renewable energy. Returns up to 200 subsidy listings including program details, eligibility, and application information. Valuable for companies exploring clean energy investment opportunities in Japan.

### Use Cases

#### Foreign Companies Entering the Japanese Market

Japan's government procurement market is one of the largest in Asia, governed by WTO Government Procurement Agreement (GPA) rules that require international openness. This Actor helps foreign businesses discover active procurement opportunities from the Cabinet Office, identify relevant subsidy programs through jGrants that could offset market entry costs, and research the regulatory and data landscape through e-Gov open data. Whether you're an IT services provider, construction firm, or consulting company, programmatic access to Japanese procurement data gives you a competitive edge.

#### Academic and Policy Researchers

Japan publishes extensive open data through its e-Gov portal covering demographics, economics, environmental monitoring, healthcare statistics, and more. Researchers studying Japanese public policy, economic trends, or comparative government data can use this Actor to programmatically search and collect datasets without navigating Japanese-language government websites. Combined with jGrants data, researchers can also track government spending priorities and subsidy allocation patterns across sectors.

#### Procurement Analysts and Government Contract Specialists

For analysts monitoring government spending and contract awards across Asia-Pacific, this Actor provides structured access to Japanese Cabinet Office procurement notices. By running scheduled searches with relevant keywords, analysts can build databases of Japanese government procurement activity, track trends in government IT spending, identify recurring contract patterns, and generate reports on procurement opportunities for their clients or organizations.

#### Grant and Subsidy Consultants

Consultants who help businesses apply for Japanese government subsidies can use the jGrants search to stay current on available programs. By searching for industry-specific keywords, consultants can quickly identify new subsidy opportunities, track program changes, and match clients with relevant funding sources — all without manually browsing the jGrants portal.

### Cost Estimate

This Actor makes lightweight API calls and processes structured JSON responses. Typical runs consume minimal compute resources:

- A search across all 3 sources with default settings (50 results each) completes in under 10 seconds and costs approximately **$0.001–$0.005** on the Apify platform.
- Maximum-scale runs (200 results × 3 sources) remain well under **$0.01** per run.
- Scheduled daily runs for monitoring purposes would cost roughly **$0.05–$0.15 per month**.

The primary cost factor is the SIP API key usage rather than Apify compute. Check your SIP Public Data Gateway plan for API call limits.

### Legal and Data Usage

All data returned by this Actor originates from official Japanese government sources:

- **e-Gov Open Data Catalog** — Published under Japan's open data policy encouraging reuse of government data.
- **Cabinet Office Procurement** — Public procurement notices published in compliance with transparency requirements.
- **jGrants** — Publicly listed subsidy program information intended for broad access.

Users are responsible for complying with applicable terms of use for each data source and any restrictions on commercial use or redistribution. This Actor provides search and retrieval functionality only and does not modify or store government data beyond the Apify dataset.

### Related Actors

- [Japan e-Stat Statistics Search](https://apify.com/store) — Search Japan's official statistics portal for demographic, economic, and social data.
- [Japan Patent Search](https://apify.com/store) — Search Japanese patent and intellectual property databases.
- [Government Procurement Monitor](https://apify.com/store) — Monitor government procurement across multiple countries.

### Support

If you encounter issues or have feature requests, please open an issue on the Actor's GitHub repository or contact us through the Apify platform. We welcome feedback on additional Japanese government data sources to integrate.

### Use as MCP Tool (AI Agent Integration)

This Actor works as an MCP tool — AI agents (Claude, GPT, Cursor) can discover and run it automatically.

#### Quick setup (Claude Desktop / Cursor / VS Code)

Add to your MCP config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Then ask your AI: *"Search for Toyota in Japanese government databases"*

#### Direct API call

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("lentic_clockss/japan-government-data-search").call(
    run_input={"searchTerms": ["Toyota"], "maxResultsPerSource": 50}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Other Data API Actors

- [US Business Entity Data API](https://apify.com/lentic_clockss/us-business-entity-search)
- [Taiwan Government Data API](https://apify.com/lentic_clockss/taiwan-data-search)
- [Singapore Government Data API](https://apify.com/lentic_clockss/singapore-government-data-search)
- [EU Business & Company Registry API](https://apify.com/lentic_clockss/eu-business-data-search)

# Actor input Schema

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

Keywords to search across selected Japanese government data sources (e.g. 'Tokyo', 'subsidy', 'transport', 'health'). Each term is searched across all enabled sources in parallel.

## `includeOpenDataPortal` (type: `boolean`):

Search Japan's central e-Gov open data catalog for datasets, statistical collections, and ministry open data.

## `includeProcurement` (type: `boolean`):

Search Cabinet Office procurement and tender notice links.

## `includeSubsidies` (type: `boolean`):

Search Japan's jGrants subsidy program listings.

## `maxResultsPerSource` (type: `integer`):

Maximum records to return per data source (gateway caps at 200).

## `keyword` (type: `string`):

Backward-compatibility field for older runs. Prefer searchTerms.

## `sources` (type: `array`):

Backward-compatibility field for older runs. Prefer includeOpenDataPortal / includeProcurement / includeSubsidies.

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

Backward-compatibility field for older runs. Prefer maxResultsPerSource.

## Actor input object example

```json
{
  "searchTerms": [
    "Tokyo"
  ],
  "includeOpenDataPortal": true,
  "includeProcurement": true,
  "includeSubsidies": true,
  "maxResultsPerSource": 50,
  "keyword": "Tokyo",
  "sources": [
    "egov_catalog",
    "cao_procurement",
    "jgrants"
  ],
  "maxResults": 50
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all government data records

# 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": [
        "Tokyo"
    ],
    "keyword": "Tokyo"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/japan-government-data-search").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": ["Tokyo"],
    "keyword": "Tokyo",
}

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/japan-government-data-search").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": [
    "Tokyo"
  ],
  "keyword": "Tokyo"
}' |
apify call lentic_clockss/japan-government-data-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lentic_clockss/japan-government-data-search",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Japan Government Data API",
        "description": "Search Japanese government procurement, e-Gov open data catalog, and jGrants subsidies via SIP Public Data Gateway API.",
        "version": "0.1",
        "x-build-id": "NX4wjdB76XgEvJDid"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~japan-government-data-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-japan-government-data-search",
                "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/lentic_clockss~japan-government-data-search/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-japan-government-data-search",
                "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/lentic_clockss~japan-government-data-search/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-japan-government-data-search",
                "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 across selected Japanese government data sources (e.g. 'Tokyo', 'subsidy', 'transport', 'health'). Each term is searched across all enabled sources in parallel.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeOpenDataPortal": {
                        "title": "Include e-Gov open data catalog",
                        "type": "boolean",
                        "description": "Search Japan's central e-Gov open data catalog for datasets, statistical collections, and ministry open data.",
                        "default": true
                    },
                    "includeProcurement": {
                        "title": "Include Cabinet Office procurement",
                        "type": "boolean",
                        "description": "Search Cabinet Office procurement and tender notice links.",
                        "default": true
                    },
                    "includeSubsidies": {
                        "title": "Include jGrants subsidies",
                        "type": "boolean",
                        "description": "Search Japan's jGrants subsidy program listings.",
                        "default": true
                    },
                    "maxResultsPerSource": {
                        "title": "Max results per source",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum records to return per data source (gateway caps at 200).",
                        "default": 50
                    },
                    "keyword": {
                        "title": "Legacy keyword (deprecated)",
                        "type": "string",
                        "description": "Backward-compatibility field for older runs. Prefer searchTerms."
                    },
                    "sources": {
                        "title": "Legacy sources (deprecated)",
                        "type": "array",
                        "description": "Backward-compatibility field for older runs. Prefer includeOpenDataPortal / includeProcurement / includeSubsidies.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "egov_catalog",
                                "cao_procurement",
                                "jgrants"
                            ]
                        },
                        "default": [
                            "egov_catalog",
                            "cao_procurement",
                            "jgrants"
                        ]
                    },
                    "maxResults": {
                        "title": "Legacy max results (deprecated)",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Backward-compatibility field for older runs. Prefer maxResultsPerSource.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```