# Coursera Course Search Scraper (`fetch_cat/coursera-course-search-scraper`) Actor

Scrape public Coursera search results with course titles, partners, ratings, reviews, skills, levels, durations, images, and URLs.

- **URL**: https://apify.com/fetch\_cat/coursera-course-search-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Education, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.04 / 1,000 item extracteds

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

## Coursera Course Search Scraper

Extract public Coursera course search results for market research, catalog monitoring, lead generation, SEO analysis, and learning-content intelligence.

### What does Coursera Course Search Scraper do?

Coursera Course Search Scraper collects public course cards from Coursera search pages.

It turns search phrases such as `data science`, `python`, or `project management` into structured dataset rows.

Each row includes the course courseTitle, provider, URL, image, rating, review text, level, duration, skills, type, position, and timestamp.

Use it when you need repeatable course catalog data without manually copying search pages.

### Who is it for?

- 🎓 L&D teams comparing learning vendors and course coverage.
- 📊 Edtech analysts tracking course supply in fast-moving skill categories.
- 🧑‍🏫 Course creators researching competitive course titles and positioning.
- 🧩 Course aggregators building searchable education catalogs.
- 🔎 SEO teams monitoring Coursera result pages for topic clusters.
- 🏢 Talent teams mapping skills to available learning options.

### Why use this actor?

Coursera has a large public education catalog.

Manual research is slow when you need many topics.

This actor gives you clean rows that are easy to filter, export, enrich, and compare.

You can run the same query list weekly or monthly and watch changes in course availability.

### What data can you extract?

| Field | Description |
| --- | --- |
| `query` | Search phrase connected to the course result. |
| `courseTitle` | Course, certificate, degree, or project title. |
| `partnerNames` | Coursera partners or institutions when visible. |
| `url` | Absolute Coursera URL. |
| `imageUrl` | Public card image URL when visible. |
| `rating` | Numeric rating when visible. |
| `reviewCount` | Parsed numeric review count when visible. |
| `reviewCountText` | Review count text, for example `44K reviews`. |
| `enrollmentText` | Enrollment text when present on the card. |
| `level` | Beginner, Intermediate, Advanced, or related level text. |
| `duration` | Duration shown on the card. |
| `skills` | Skills listed on the search result card. |
| `descriptionSnippet` | Short course description or summary when visible. |
| `tags` | Additional public tags or metadata labels from the result card. |
| `sourceUrl` | Search results page URL that produced the record. |
| `productType` | Course, Specialization, Professional Certificate, Degree, or related type. |
| `position` | Saved result order. |
| `scrapedAt` | ISO timestamp for the scrape. |

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee charged when a run starts. Covers fixed startup cost (init, proxy warmup, first HTTP setup). | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `item` | Charged per item extracted. | $0.06846 / 1,000 | $0.05953 / 1,000 | $0.04643 / 1,000 | $0.03572 / 1,000 | $0.02381 / 1,000 | $0.01667 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### How to use it

1. Open the actor on Apify.
2. Add one or more Coursera search queries.
3. Optionally add direct Coursera search URLs.
4. Set `maxItems` to the number of course results you need.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, or HTML.

### Input options

#### Search queries

Add course-market phrases such as:

- `data science`
- `python`
- `project management`
- `generative ai`
- `cybersecurity`

#### Coursera search URLs

You can also paste Coursera search URLs.

This is useful when you already have a filtered public search page.

#### Language filter

Use the optional language field when you want Coursera language-filtered results.

#### Maximum course results

`maxItems` controls the total saved records across all queries and URLs.

The default is intentionally small so first runs stay inexpensive.

#### Proxy configuration

The default run uses a direct connection.

Enable Apify Proxy only if your network path is blocked or unreliable.

### Example input

```json
{
  "queries": ["data science", "python"],
  "maxItems": 25,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### Example output

```json
{
  "query": "data science",
  "courseTitle": "Python for Data Science, AI & Development",
  "partnerNames": ["IBM"],
  "url": "https://www.coursera.org/learn/python-for-applied-data-science-ai",
  "imageUrl": "https://d3njjcbhbojbot.cloudfront.net/...",
  "rating": 4.6,
  "reviewCount": 44000,
  "reviewCountText": "44K reviews",
  "enrollmentText": null,
  "level": "Beginner",
  "duration": "1 - 3 Months",
  "skills": ["Data Import/Export", "Python Programming", "NumPy"],
  "descriptionSnippet": "Build data science and AI skills with Python.",
  "tags": ["Course"],
  "sourceUrl": "https://www.coursera.org/search?query=data%20science",
  "productType": "Course",
  "position": 1,
  "scrapedAt": "2026-07-03T15:00:00.000Z"
}
```

### Tips for better results

- Use specific skill phrases rather than very broad single words.
- Run separate queries for separate market segments.
- Keep a fixed query list for recurring trend monitoring.
- Export CSV for spreadsheet review.
- Export JSON for downstream enrichment pipelines.

### Use cases

#### Course catalog monitoring

Track how many Coursera results exist for important skills.

Compare titles, providers, durations, and levels across topics.

#### Competitive intelligence

Course creators can inspect competing course titles and positioning.

Analysts can monitor how partner institutions appear across keywords.

#### Skill supply research

Learning teams can identify which skills are well-covered and which are underserved.

#### SEO and content planning

Content teams can discover course vocabulary, provider names, and skill clusters.

### Integrations

Send results to Google Sheets for editorial review.

Load JSON into a warehouse for recurring catalog snapshots.

Use the Apify API to trigger scheduled weekly runs.

Connect the dataset to Make, Zapier, or n8n for automated alerts.

### 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('fetch_cat/coursera-course-search-scraper').call({
  queries: ['data science'],
  maxItems: 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('fetch_cat/coursera-course-search-scraper').call(run_input={
    'queries': ['python'],
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~coursera-course-search-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"queries":["project management"],"maxItems":25}'
```

### MCP usage

Use the Apify MCP server to run this actor from AI tools.

Claude Code example URL:

```text
https://mcp.apify.com/?tools=fetch_cat/coursera-course-search-scraper
```

Claude Code command:

```bash
claude mcp add apify-coursera "https://mcp.apify.com/?tools=fetch_cat/coursera-course-search-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-coursera": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.apify.com/?tools=fetch_cat/coursera-course-search-scraper"]
    }
  }
}
```

Example prompts:

- "Run Coursera Course Search Scraper for data science and summarize common providers."
- "Collect 50 Coursera cybersecurity courses and group them by level."
- "Compare Python and Java course search results from Coursera."

### Scheduling

Create a scheduled Apify task for recurring monitoring.

Weekly or monthly schedules are useful for market research.

Keep query lists stable when you want trend comparisons.

### Limits

The actor extracts public search-result data visible on Coursera pages.

It does not log in.

It does not enroll in courses.

It does not extract private learner data.

It may return fewer rows than requested if Coursera has fewer public results for a query.

### Troubleshooting

#### The run returns fewer items than expected

Coursera may have fewer visible results for your query, or duplicate courses may appear across pages.

Try a broader query or multiple related queries.

#### The run fails with connection errors

Retry with Apify Proxy enabled.

If the issue persists, reduce `maxItems` and test with one query.

#### Some fields are empty

Coursera does not show every field on every result card.

Fields such as enrollment count or image URL can be missing for some courses.

### Data quality notes

Values are normalized from public result cards.

Ratings are numbers when visible.

Review counts are preserved as display text because Coursera may abbreviate them.

Skills are split into arrays for easier filtering.

### Legality

This actor collects publicly available course search information.

You are responsible for using the data legally and respecting Coursera's terms, privacy rules, and applicable laws.

Do not use the actor to collect private account data.

### Related actors

Explore other education and search actors from the same developer account on Apify:

- https://apify.com/fetch\_cat/google-search-scraper
- https://apify.com/fetch\_cat/youtube-search-scraper
- https://apify.com/fetch\_cat/udemy-course-search-scraper

### FAQ

#### Can I search multiple Coursera topics in one run?

Yes. Add multiple values to `queries` and set a large enough `maxItems`.

#### Can I scrape a direct Coursera search URL?

Yes. Paste it into `startUrls`.

#### Does this actor need a Coursera account?

No. It targets public search results only.

#### Can I get course reviews?

No. This version extracts search result cards, not detailed review pages.

#### Can I use proxies?

Yes. Use the proxy configuration field if needed.

# Actor input Schema

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

Coursera search phrases to collect course results for.

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

Optional Coursera /search URLs to scrape in addition to the search queries.

## `language` (type: `string`):

Optional Coursera language filter value, for example English or Spanish.

## `productType` (type: `string`):

Optional Coursera product type filter, for example Course, Specialization, Professional Certificate, or Guided Project.

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

Maximum number of Coursera course records to save for each query or start URL.

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

Safety limit for Coursera pagination per query.

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

Optional Apify Proxy settings. Leave disabled unless Coursera blocks your connection.

## Actor input object example

```json
{
  "queries": [
    "data science",
    "python"
  ],
  "startUrls": [
    {
      "url": "https://www.coursera.org/search?query=project%20management"
    }
  ],
  "language": "English",
  "productType": "",
  "maxItems": 20,
  "maxPagesPerQuery": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "queries": [
        "data science",
        "python"
    ],
    "startUrls": [
        {
            "url": "https://www.coursera.org/search?query=project%20management"
        }
    ],
    "language": "English",
    "productType": "",
    "maxItems": 20,
    "maxPagesPerQuery": 3
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "queries": [
        "data science",
        "python",
    ],
    "startUrls": [{ "url": "https://www.coursera.org/search?query=project%20management" }],
    "language": "English",
    "productType": "",
    "maxItems": 20,
    "maxPagesPerQuery": 3,
}

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

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

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

```

## CLI example

```bash
echo '{
  "queries": [
    "data science",
    "python"
  ],
  "startUrls": [
    {
      "url": "https://www.coursera.org/search?query=project%20management"
    }
  ],
  "language": "English",
  "productType": "",
  "maxItems": 20,
  "maxPagesPerQuery": 3
}' |
apify call fetch_cat/coursera-course-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Coursera Course Search Scraper",
        "description": "Scrape public Coursera search results with course titles, partners, ratings, reviews, skills, levels, durations, images, and URLs.",
        "version": "0.1",
        "x-build-id": "coNBrQJQGumEyheFl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~coursera-course-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-coursera-course-search-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~coursera-course-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-coursera-course-search-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~coursera-course-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-coursera-course-search-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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Coursera search phrases to collect course results for.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "data science"
                        ]
                    },
                    "startUrls": {
                        "title": "Coursera search URLs",
                        "type": "array",
                        "description": "Optional Coursera /search URLs to scrape in addition to the search queries.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "language": {
                        "title": "Language filter",
                        "type": "string",
                        "description": "Optional Coursera language filter value, for example English or Spanish."
                    },
                    "productType": {
                        "title": "Product type filter",
                        "enum": [
                            "",
                            "Course",
                            "Specialization",
                            "Professional Certificate",
                            "Guided Project",
                            "Degree"
                        ],
                        "type": "string",
                        "description": "Optional Coursera product type filter, for example Course, Specialization, Professional Certificate, or Guided Project.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Maximum course results per query",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Coursera course records to save for each query or start URL.",
                        "default": 25
                    },
                    "maxPagesPerQuery": {
                        "title": "Maximum pages per query",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Safety limit for Coursera pagination per query.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Leave disabled unless Coursera blocks your connection.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
