# Google Scholar Profiles Scraper (`fetch_cat/google-scholar-profiles-scraper`) Actor

Extract public Google Scholar author profiles, citation metrics, h-index, i10-index, interests, coauthors, and publication rows from profile URLs or user IDs.

- **URL**: https://apify.com/fetch\_cat/google-scholar-profiles-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.21 / 1,000 profile results

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 Scholar Profiles Scraper

Extract public Google Scholar author profiles, citation metrics, interests, coauthors, and publication rows from profile URLs or user IDs.

### What does Google Scholar Profiles Scraper do?

Google Scholar Profiles Scraper turns public Google Scholar author pages into a clean Apify dataset.

It helps you collect structured academic profile data without copying fields by hand.

You can provide full profile URLs or the `user` IDs from Google Scholar profile links.

The actor returns author identity fields, affiliation, verified email domain, research interests, citation metrics, visible publication rows, and optional coauthor cards.

It is designed for small to medium research-intelligence workflows that need repeatable exports.

### Who is it for?

- 🎓 University research offices tracking faculty visibility.
- 🧪 Research intelligence teams building scholar directories.
- 🧑‍💼 Academic recruiters finding subject-matter experts.
- 📚 Publishers and journals mapping authors in a field.
- 🔎 SEO and content analysts reviewing public academic authority signals.
- 🧩 Data enrichment teams matching researcher names to public profile evidence.

### Why use this Google Scholar scraper?

Manual profile review is slow and inconsistent.

This actor gives you the same set of fields for every public profile you submit.

It is useful when you already have profile URLs from search, CRM records, author pages, or internal lists.

The output is ready for CSV, JSON, Excel, API, Make, Zapier, or database pipelines.

### Use Google Scholar profile data as a public researcher API

Use this actor as a repeatable public researcher-data workflow for profile enrichment, citation monitoring, publication exports, and academic authority review. It is not an official Google Scholar API, and it only collects data visible on public Google Scholar profile pages.

### What data can you extract?

Citation metrics are foregrounded in the output: total citations, recent citations, h-index, i10-index, public interests, coauthors, and visible publication rows.

| Field | Description |
| --- | --- |
| `profileUrl` | Final public Google Scholar profile URL |
| `userId` | Google Scholar user ID from the URL |
| `name` | Public author name |
| `affiliation` | Public affiliation line |
| `verifiedEmailDomain` | Verified email domain when shown |
| `interests` | Public research interest tags |
| `citations` | Total citation count |
| `citationsSince2019` | Recent citation count shown by Google Scholar |
| `hIndex` | Total h-index |
| `hIndexSince2019` | Recent h-index |
| `i10Index` | Total i10-index |
| `i10IndexSince2019` | Recent i10-index |
| `publicationCount` | Number of publication rows saved |
| `publications` | Visible publication rows with title, authors, venue, year, citations, and URL |
| `coauthors` | Visible coauthor cards when enabled |
| `scrapedAt` | Timestamp for freshness tracking |

### How much does it cost to scrape Google Scholar profiles?

This actor uses pay-per-event pricing.

You pay a small start fee per run and a formula-derived per-profile result fee for each saved profile. The BRONZE tier is about $2.03 per 1,000 saved profiles, with lower per-profile rates on higher platform tiers.

The default test input is intentionally small so your first run stays inexpensive.

For best cost control, start with one or two profiles and increase volume after checking the output.

### Input options

#### Google Scholar profile URLs

Use `profileUrls` when you have full profile links.

Example:

```json
[
  { "url": "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en" }
]
````

#### Google Scholar user IDs

Use `userIds` when you only have the `user=` value.

Example:

```json
["qc6CJjYAAAAJ"]
```

#### Maximum publications per profile

Use `maxPublications` to control how many visible publication rows are included for each profile.

Set it to `0` if you only need profile-level metrics.

#### Include coauthors

Use `includeCoauthors` to include or skip visible coauthor cards.

### Example input

```json
{
  "profileUrls": [
    { "url": "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en" }
  ],
  "userIds": [],
  "maxPublications": 10,
  "includeCoauthors": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Example output

```json
{
  "profileUrl": "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en",
  "userId": "qc6CJjYAAAAJ",
  "name": "Albert Einstein",
  "affiliation": "Professor of Physics",
  "verifiedEmailDomain": "example.edu",
  "interests": ["Physics", "Relativity"],
  "citations": 123456,
  "citationsSince2019": 12345,
  "hIndex": 99,
  "hIndexSince2019": 40,
  "i10Index": 200,
  "i10IndexSince2019": 80,
  "publicationCount": 10,
  "publications": [
    {
      "title": "Example publication title",
      "authors": "A Einstein",
      "venue": "Journal name",
      "year": 1915,
      "citations": 1000,
      "url": "https://scholar.google.com/citations?..."
    }
  ],
  "coauthors": [],
  "scrapedAt": "2026-06-24T00:00:00.000Z"
}
```

### How to scrape Google Scholar author profiles

1. Open the actor input form.
2. Paste one or more public Google Scholar profile URLs.
3. Or paste one or more Google Scholar user IDs.
4. Choose the maximum number of publication rows per profile.
5. Decide whether to include coauthors.
6. Run the actor.
7. Download the dataset as CSV, JSON, Excel, XML, or HTML.

### Tips for better results

- ✅ Use public profile URLs, not search-result URLs.
- ✅ Keep the first run small to confirm field coverage.
- ✅ Use user IDs when you have already normalized profiles in your own database.
- ✅ Lower `maxPublications` if you only need citation metrics.
- ✅ Enable proxy settings only if your run is rate-limited.

### Working with rate limits

Google Scholar can limit automated traffic.

If a run reports a challenge or unusual-traffic page, retry later with a smaller batch.

For larger batches, use Apify residential proxy and keep runs conservative.

The actor is designed to stop clearly when challenged instead of saving empty rows.

### Integrations

Use the actor with Apify integrations to automate research workflows.

- 📄 Export to Google Sheets for manual review.
- 🧱 Send JSON to a data warehouse.
- 🔔 Trigger a Make scenario when a dataset is ready.
- 🧩 Enrich CRM records with public citation metrics.
- 📊 Feed dashboards with profile-level metrics.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/google-scholar-profiles-scraper').call({
  profileUrls: [{ url: 'https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en' }],
  maxPublications: 10,
  includeCoauthors: true
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/google-scholar-profiles-scraper').call(run_input={
    'userIds': ['qc6CJjYAAAAJ'],
    'maxPublications': 10,
    'includeCoauthors': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~google-scholar-profiles-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"userIds":["qc6CJjYAAAAJ"],"maxPublications":10,"includeCoauthors":true,"proxyConfiguration":{"useApifyProxy":true,"apifyProxyGroups":["RESIDENTIAL"]}}'
```

### MCP usage

You can run this actor from AI tools through the Apify MCP server.

Use this MCP URL pattern:

```text
https://mcp.apify.com/?tools=fetch_cat/google-scholar-profiles-scraper
```

Claude Code setup example:

```bash
claude mcp add apify-google-scholar-profiles "https://mcp.apify.com/?tools=fetch_cat/google-scholar-profiles-scraper"
```

Claude Desktop JSON example:

```json
{
  "mcpServers": {
    "apify-google-scholar-profiles": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/google-scholar-profiles-scraper"
    }
  }
}
```

Example prompts:

- "Run the Google Scholar Profiles Scraper for these three profile URLs and summarize the h-index values."
- "Extract publication rows for this Scholar user ID and export the dataset link."
- "Compare citation metrics for these public author profiles."

### Data quality notes

The actor returns fields visible on the public profile page at run time.

Some profiles may hide verified email information.

Some profiles may have fewer visible publication rows than your requested maximum.

Citation metrics can change over time as Google Scholar updates its index.

### Limitations

This actor does not log into Google accounts.

It does not scrape private, hidden, or account-only data.

It does not guarantee that every Google Scholar profile is reachable at all times.

Large batches may require slower runs or proxy settings.

### Legality

This actor extracts publicly visible profile information.

You are responsible for using the data lawfully and respecting applicable privacy, copyright, database, and platform rules.

Avoid collecting or processing personal data unless you have a valid legal basis.

### FAQ and troubleshooting

#### Why did my run stop with a challenge message?

Google Scholar may have returned a rate-limit or unusual-traffic page.

Try a smaller batch, wait before retrying, or enable proxy settings.

#### Why are some publication fields empty?

Google Scholar pages do not always show every field for every publication row.

The actor saves the fields that are visible on the profile page.

#### Why did a profile produce no row?

The profile may be deleted, private, malformed, or temporarily unavailable.

Check that the URL contains a valid `user=` parameter.

#### Can I scrape publications for each Google Scholar profile?

Yes. Set `maxPublications` above `0` to include visible publication rows with titles, authors, venues, years, citations, and URLs where Google Scholar exposes them.

#### Can I monitor citation metrics over time?

Yes. Run the actor on a schedule and compare `citations`, `citationsSince2019`, `hIndex`, `hIndexSince2019`, `i10Index`, and `i10IndexSince2019` across datasets.

#### Does this access private or logged-in Google data?

No. The actor is limited to public Google Scholar profile pages. It does not log in, bypass Google restrictions, or access private account data.

### Related scrapers

Explore related actors from `fetch_cat`:

- https://apify.com/fetch\_cat/google-news-scraper
- https://apify.com/fetch\_cat/google-autocomplete-scraper
- https://apify.com/fetch\_cat/bing-search-results-scraper

### Support

If you need a field that is visible on public Google Scholar pages but missing from the dataset, open an issue with an example profile URL.

Include your run ID and a short description of the expected field.

### Changelog

#### 0.1

Initial build with public profile metadata, citation metrics, interests, publication rows, coauthors, and Apify dataset output.

# Actor input Schema

## `profileUrls` (type: `array`):

Public Google Scholar author profile URLs, for example https://scholar.google.com/citations?user=qc6CJjYAAAAJ\&hl=en. You can also paste bare user IDs.

## `userIds` (type: `array`):

Optional Google Scholar user IDs from the `user=` URL parameter. Use this when you have IDs instead of full URLs.

## `maxPublications` (type: `integer`):

Maximum number of visible publication rows to include for each author profile.

## `includeCoauthors` (type: `boolean`):

Extract the visible coauthor cards shown on the public profile when available.

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

Proxy settings. Google Scholar often blocks cloud datacenter traffic, so the working prefill uses Apify residential proxy for reliable profile fetches.

## Actor input object example

```json
{
  "profileUrls": [
    {
      "url": "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en"
    }
  ],
  "userIds": [],
  "maxPublications": 10,
  "includeCoauthors": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "profileUrls": [
        {
            "url": "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en"
        }
    ],
    "userIds": [],
    "maxPublications": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/google-scholar-profiles-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "profileUrls": [{ "url": "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en" }],
    "userIds": [],
    "maxPublications": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/google-scholar-profiles-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "profileUrls": [
    {
      "url": "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en"
    }
  ],
  "userIds": [],
  "maxPublications": 10
}' |
apify call fetch_cat/google-scholar-profiles-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Scholar Profiles Scraper",
        "description": "Extract public Google Scholar author profiles, citation metrics, h-index, i10-index, interests, coauthors, and publication rows from profile URLs or user IDs.",
        "version": "0.1",
        "x-build-id": "rkHOkS6wPg6Rxtedk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~google-scholar-profiles-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-google-scholar-profiles-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fetch_cat~google-scholar-profiles-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-google-scholar-profiles-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fetch_cat~google-scholar-profiles-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-google-scholar-profiles-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "profileUrls": {
                        "title": "Google Scholar profile URLs",
                        "type": "array",
                        "description": "Public Google Scholar author profile URLs, for example https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en. You can also paste bare user IDs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "userIds": {
                        "title": "Google Scholar user IDs",
                        "type": "array",
                        "description": "Optional Google Scholar user IDs from the `user=` URL parameter. Use this when you have IDs instead of full URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPublications": {
                        "title": "Maximum publications per profile",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of visible publication rows to include for each author profile.",
                        "default": 20
                    },
                    "includeCoauthors": {
                        "title": "Include visible coauthors",
                        "type": "boolean",
                        "description": "Extract the visible coauthor cards shown on the public profile when available.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Google Scholar often blocks cloud datacenter traffic, so the working prefill uses Apify residential proxy for reliable profile fetches.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```