# Google Sheet Exporter (`automation-lab/google-sheet-exporter`) Actor

Export public Google Sheets to clean dataset rows with normalized headers, raw cells, sheet IDs, gids, and CSV/JSON automation outputs.

- **URL**: https://apify.com/automation-lab/google-sheet-exporter.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.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

## Google Sheet Exporter

Export public Google Sheets to clean Apify dataset rows, JSON, CSV, Excel, webhooks, and API workflows.

Google Sheet Exporter turns any public/shared Google Sheet into structured dataset records. Paste a spreadsheet URL, a spreadsheet ID, or a direct CSV export URL, and the actor fetches the public CSV feed, parses the header row, normalizes duplicate or blank column names, and saves one dataset item per sheet row.

### What does Google Sheet Exporter do?

Google Sheet Exporter reads public Google Sheets through their CSV export endpoint and converts rows into structured Apify dataset items.

It is useful when you need to:

- ✅ Import a public Google Sheet into an Apify automation.
- ✅ Schedule recurring exports from shared operations sheets.
- ✅ Convert a published Google Sheet to JSON without writing glue code.
- ✅ Preserve row numbers, tab gids, raw cells, and normalized column names.
- ✅ Send Google Sheet rows to webhooks, Make, Zapier, Airtable, BigQuery, or your own API.

### Who is it for?

This actor is built for automation operators, data teams, developers, no-code builders, marketers, analysts, and lead generation teams that already use Google Sheets as a lightweight database.

Common users include:

- 🧑‍💻 Developers who need a simple Google Sheets CSV to JSON API.
- 📊 Analysts who want scheduled copies of public spreadsheet data.
- 🧰 No-code operators who connect Apify datasets to Make or Zapier.
- 🧾 Lead teams that receive public prospect lists in Google Sheets.
- 🏛️ Civic, research, and community teams that publish open spreadsheets.

### Why use it?

Google Sheets already has export URLs, but production workflows need more than a raw CSV download. This actor adds validation, parsing, metadata, normalized keys, dataset storage, scheduling, API access, and integrations.

You get repeatable exports with clear errors when a sheet is private or not published.

### Supported Google Sheet inputs

You can paste:

- Standard Google Sheet edit URLs.
- Spreadsheet IDs.
- URLs with `#gid=...` for specific tabs.
- Direct `/export?format=csv` URLs.
- Published CSV URLs with `output=csv`.

### Data output table

| Field | Description |
| --- | --- |
| `_rowNumber` | Row number in the source sheet. The header row is row 1. |
| `_sourceUrl` | The URL or ID you entered. |
| `_fetchUrl` | The resolved public CSV URL used by the actor. |
| `_sheetId` | Parsed spreadsheet ID when available. |
| `_gid` | Worksheet tab gid. |
| `_fetchedAt` | Timestamp for the export run. |
| `_rawRow` | Original CSV cells as an array. |
| `columns` | Object with normalized header keys and cell values. |
| Dynamic columns | Top-level normalized columns such as `email`, `company`, or `student_name`. |

### How much does it cost to export Google Sheets?

The actor uses pay-per-event pricing. Each run has a small start fee and then charges per exported row. Small test runs are inexpensive, and larger scheduled exports receive tiered per-row discounts.

Because this actor uses direct HTTP CSV exports and no browser, compute costs are low.

### How to use Google Sheet Exporter

1. Open the actor on Apify.
2. Add one or more public Google Sheet URLs or IDs.
3. Set a `gid` if your URL does not already include the tab you need.
4. Choose the maximum rows per sheet.
5. Run the actor.
6. Download the dataset as JSON, CSV, Excel, XML, or RSS.
7. Connect the dataset to your automation workflow.

### Input settings

#### Sheet URLs or IDs

Use `startUrls` for all sheet sources. You can add one source or many sources in the same run.

#### Worksheet gid override

Use `gid` when you paste a spreadsheet ID or a URL without a tab identifier. Google Sheets usually uses `gid=0` for the first tab.

#### Maximum rows per sheet

Use `maxRowsPerSheet` to cap output volume. The actor always treats the first CSV row as headers and starts emitting data from row 2.

#### Trim cell values

Enable `trimValues` to remove surrounding whitespace from cells.

#### Include raw row arrays

Enable `includeRawRow` when you need the original CSV row alongside normalized fields.

#### Skip blank rows

Enable `skipBlankRows` to ignore empty spacer rows.

### Output example

```json
{
  "_rowNumber": 2,
  "_sourceUrl": "https://docs.google.com/spreadsheets/d/1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms/edit#gid=0",
  "_sheetId": "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms",
  "_gid": "0",
  "_fetchedAt": "2026-06-21T00:00:00.000Z",
  "_rawRow": ["Alexandra", "Female", "4. Senior", "CA", "English", "Drama Club"],
  "columns": {
    "student_name": "Alexandra",
    "gender": "Female",
    "class_level": "4. Senior"
  },
  "student_name": "Alexandra",
  "gender": "Female",
  "class_level": "4. Senior"
}
````

### Header normalization

Headers are converted to lowercase snake\_case keys.

Examples:

- `Student Name` becomes `student_name`.
- `E-mail Address` becomes `e_mail_address`.
- blank headers become `column_1`, `column_2`, and so on.
- duplicate headers receive suffixes such as `status_2`.

### Exporting multiple tabs

Google Sheets identifies each tab with a `gid`. To export multiple tabs, add the same spreadsheet more than once with different `gid` values in the URL, or run separate tasks for each tab.

Automatic tab discovery is intentionally not required for reliable v1 exports. Explicit gids keep the workflow predictable.

### Private sheet troubleshooting

The actor only supports public/shared/published sheets that Google can export without account cookies or OAuth.

If a run fails with a permission message:

1. Open the sheet in Google Sheets.
2. Click Share.
3. Allow access to anyone with the link, or publish the sheet.
4. Re-run the actor with the same URL.

### Tips for reliable exports

- ✅ Put stable column names in row 1.
- ✅ Avoid merged cells in source data tabs.
- ✅ Use explicit `gid` values for multi-tab spreadsheets.
- ✅ Keep `maxRowsPerSheet` small for smoke tests.
- ✅ Schedule recurring runs for monitoring public sheets.

### Integrations

Google Sheet Exporter works with Apify datasets and integrations:

- Send rows to a webhook after every run.
- Sync dataset items to Make or Zapier.
- Download CSV or Excel for reporting.
- Call the actor from a backend using the Apify API.
- Chain it before enrichment, validation, or lead scoring actors.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/google-sheet-exporter').call({
  startUrls: [{ url: 'https://docs.google.com/spreadsheets/d/1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms/edit#gid=0' }],
  maxRowsPerSheet: 25
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/google-sheet-exporter').call(run_input={
    'startUrls': [{'url': 'https://docs.google.com/spreadsheets/d/1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms/edit#gid=0'}],
    'maxRowsPerSheet': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~google-sheet-exporter/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://docs.google.com/spreadsheets/d/1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms/edit#gid=0"}],"maxRowsPerSheet":25}'
```

### MCP usage

Use this actor from Apify MCP with Claude Code, Claude Desktop, or other MCP clients.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/google-sheet-exporter
```

Claude Code setup:

```bash
claude mcp add apify-google-sheet-exporter https://mcp.apify.com/?tools=automation-lab/google-sheet-exporter
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-google-sheet-exporter": {
      "url": "https://mcp.apify.com/?tools=automation-lab/google-sheet-exporter"
    }
  }
}
```

Example prompts:

- “Export this public Google Sheet and summarize the rows.”
- “Run Google Sheet Exporter every day and compare today’s dataset with yesterday’s.”
- “Convert this public spreadsheet to JSON and send the rows to my webhook.”

### Scheduling

Create an Apify task with your sheet URL and schedule it hourly, daily, or weekly. This is useful for public directories, lead lists, signup sheets, inventory trackers, and research datasets.

### Limitations

- Private Google account data is not supported.
- The actor does not use OAuth.
- The first row is treated as headers.
- Automatic worksheet discovery is not part of v1.
- Google may block export for sheets that are not public or not shared correctly.

### Legality

Only export sheets you are allowed to access. Public Google Sheets can contain personal or sensitive data, so review the source’s terms, privacy expectations, and applicable laws before storing or processing rows.

### FAQ

#### Can it export private Google Sheets?

No. The actor intentionally supports public/shared sheets only. Private account access would require OAuth and user-specific permissions.

#### Can I export multiple sheets in one run?

Yes. Add multiple `startUrls`. For multiple tabs from the same spreadsheet, include each tab URL with its own `gid`.

#### Why did my run return a permission error?

Google returned an HTML permission or sign-in page instead of CSV. Share or publish the sheet publicly, then run again.

#### Does it preserve original column names?

The original row is preserved in `_rawRow`. Normalized names are used in `columns` and top-level fields for easier integrations.

### Related scrapers and utilities

- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/sitemap-url-extractor
- https://apify.com/automation-lab/domain-availability-checker
- https://apify.com/automation-lab/seo-audit-tool

### Changelog

- v0.1 — Initial public Google Sheets CSV export, batch URLs, row metadata, raw rows, and normalized columns.

# Actor input Schema

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

Public Google Sheet edit URLs, published CSV URLs, or direct /export?format=csv URLs. Add the same sheet with different gid values to export multiple tabs. Bare IDs can go in Spreadsheet IDs below.

## `sheetIds` (type: `array`):

Optional bare Google spreadsheet IDs to export. Use this when you have only the ID instead of a full URL.

## `gid` (type: `string`):

Optional worksheet gid to use when an input URL does not include #gid=. Leave blank for the first tab (gid 0).

## `maxRowsPerSheet` (type: `integer`):

Maximum data rows to emit from each sheet, excluding the header row.

## `trimValues` (type: `boolean`):

Remove surrounding whitespace from every exported cell value.

## `includeRawRow` (type: `boolean`):

Add \_rawRow with the original CSV cell array alongside normalized column fields.

## `skipBlankRows` (type: `boolean`):

Do not emit rows where every cell is empty.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://docs.google.com/spreadsheets/d/1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms/edit#gid=0"
    }
  ],
  "sheetIds": [],
  "gid": "0",
  "maxRowsPerSheet": 20,
  "trimValues": true,
  "includeRawRow": true,
  "skipBlankRows": true
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://docs.google.com/spreadsheets/d/1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms/edit#gid=0"
        }
    ],
    "sheetIds": [],
    "gid": "0",
    "maxRowsPerSheet": 20,
    "trimValues": true,
    "includeRawRow": true,
    "skipBlankRows": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/google-sheet-exporter").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 = {
    "startUrls": [{ "url": "https://docs.google.com/spreadsheets/d/1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms/edit#gid=0" }],
    "sheetIds": [],
    "gid": "0",
    "maxRowsPerSheet": 20,
    "trimValues": True,
    "includeRawRow": True,
    "skipBlankRows": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/google-sheet-exporter").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 '{
  "startUrls": [
    {
      "url": "https://docs.google.com/spreadsheets/d/1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms/edit#gid=0"
    }
  ],
  "sheetIds": [],
  "gid": "0",
  "maxRowsPerSheet": 20,
  "trimValues": true,
  "includeRawRow": true,
  "skipBlankRows": true
}' |
apify call automation-lab/google-sheet-exporter --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/google-sheet-exporter",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Sheet Exporter",
        "description": "Export public Google Sheets to clean dataset rows with normalized headers, raw cells, sheet IDs, gids, and CSV/JSON automation outputs.",
        "version": "0.1",
        "x-build-id": "SOTelAL7OdxKIkbmQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~google-sheet-exporter/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-google-sheet-exporter",
                "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/automation-lab~google-sheet-exporter/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-google-sheet-exporter",
                "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/automation-lab~google-sheet-exporter/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-google-sheet-exporter",
                "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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Sheet URLs or IDs",
                        "type": "array",
                        "description": "Public Google Sheet edit URLs, published CSV URLs, or direct /export?format=csv URLs. Add the same sheet with different gid values to export multiple tabs. Bare IDs can go in Spreadsheet IDs below.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "sheetIds": {
                        "title": "Spreadsheet IDs",
                        "type": "array",
                        "description": "Optional bare Google spreadsheet IDs to export. Use this when you have only the ID instead of a full URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "gid": {
                        "title": "Worksheet gid override",
                        "type": "string",
                        "description": "Optional worksheet gid to use when an input URL does not include #gid=. Leave blank for the first tab (gid 0)."
                    },
                    "maxRowsPerSheet": {
                        "title": "Maximum rows per sheet",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum data rows to emit from each sheet, excluding the header row.",
                        "default": 1000
                    },
                    "trimValues": {
                        "title": "Trim cell values",
                        "type": "boolean",
                        "description": "Remove surrounding whitespace from every exported cell value.",
                        "default": true
                    },
                    "includeRawRow": {
                        "title": "Include raw row arrays",
                        "type": "boolean",
                        "description": "Add _rawRow with the original CSV cell array alongside normalized column fields.",
                        "default": true
                    },
                    "skipBlankRows": {
                        "title": "Skip blank rows",
                        "type": "boolean",
                        "description": "Do not emit rows where every cell is empty.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```