# Freelancer Profiles Scraper (`automation-lab/freelancer-profiles-scraper`) Actor

Scrape public Freelancer.com freelancer profiles by skill or directory URL. Extract rates, ratings, reviews, skills, summaries, and metadata.

- **URL**: https://apify.com/automation-lab/freelancer-profiles-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **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

## Freelancer Profiles Scraper

Scrape public Freelancer.com freelancer directory listings by skill or direct search URL.

### What does Freelancer Profiles Scraper do?

Freelancer Profiles Scraper collects public profile-card data from Freelancer.com directory pages.
It is designed for talent sourcing, market research, competitive analysis, and lead list building.
The actor reads server-rendered Freelancer.com directory pages and saves clean rows to an Apify dataset.

### Who is it for?

**Recruiters and talent sourcers** use it to build candidate lists for niche technical skills, compare public ratings, and find freelancers with the right visible experience before shortlisting.

**Agencies and outsourcing teams** use it to benchmark freelancer rates, profile positioning, review volume, and skill coverage before deciding whether to hire, partner, or compete in a category.

**Market researchers and analysts** use it to map supply in outsourcing categories, monitor how crowded a skill market is, and compare public profile signals across repeated searches.

**Sales and partnership teams** use it to discover service providers, agencies, and independent specialists who may be good leads for software, tools, training, or collaboration.

**Founders and operators** use it to estimate talent availability and public rate bands before outsourcing web scraping, design, development, data entry, AI, or marketing work.

### Why use this actor?

✅ It focuses on public Freelancer.com profile directory data.
✅ It supports skill-based searches and direct directory URLs.
✅ It outputs normalized fields ready for spreadsheets, BI tools, and CRMs.
✅ It runs as a lightweight HTTP scraper without a browser by default.
✅ It includes ranking and source metadata for repeatable research.

### What data can you extract?

| Field | Description |
| --- | --- |
| `profileUrl` | Public Freelancer.com profile URL |
| `username` | Freelancer username visible in the directory |
| `displayName` | Display name, currently the visible username from directory cards |
| `title` | Headline or short tagline |
| `country` | Country detected from flag/location fields |
| `location` | Location text shown on the card |
| `avatarUrl` | Profile image URL |
| `rating` | Star rating when visible |
| `reviewsCount` | Number of reviews when visible |
| `hourlyRate` | Hourly rate as a number |
| `hourlyRateCurrency` | Currency code when visible |
| `earningsScore` | Freelancer.com skill/category earnings score when visible |
| `skills` | Top skills shown on the card |
| `summary` | Public profile summary snippet |
| `isOnline` | Online status when shown in HTML |
| `rankingPosition` | Position within the scraped search sequence |
| `sourceUrl` | Directory page where the profile was found |
| `scrapedAt` | ISO timestamp of extraction |

### How much does it cost to scrape Freelancer profiles?

The actor uses pay-per-event pricing: a small fixed run-start fee plus one profile event for each saved freelancer profile. You only pay the per-profile fee for rows that are actually written to the dataset.

| Example run | What it does | Approx. platform charge on FREE tier |
| --- | --- | ---: |
| Test run | 10 profiles from one skill search | about $0.006 |
| Short sourcing list | 50 profiles for one or two skills | about $0.009 |
| Category scan | 100 profiles across several pages | about $0.014 |
| Larger market sample | 1,000 profiles across multiple searches | about $0.093 |

Current event pricing:

- Run started: `$0.005` once per run.
- Profile extracted: `$0.000088482` per profile on the FREE tier.
- Paid Apify plan tiers receive lower per-profile prices through tiered pricing.

Free-plan users can usually run multiple small tests because a 100-profile sample is roughly one to two cents before any plan-specific Apify limits or platform changes. For predictable costs, start with `maxItems=20`, inspect the output, then increase `maxItems` and `maxPagesPerSearch` when you are ready for a larger dataset.

### Quick start

1. Open the actor on Apify.
2. Keep the default `web scraping` skill or add your own skills.
3. Set `maxItems` to the number of profiles you need.
4. Run the actor.
5. Download the dataset as JSON, CSV, Excel, XML, or RSS.

### Input options

#### Skills / keywords

Add Freelancer.com skill names such as:

- web scraping
- python
- data entry
- wordpress
- machine learning

The actor converts these values into public Freelancer.com skill directory URLs.

#### Start URLs

Use direct URLs when you already have a Freelancer.com directory page.
For example:

```text
https://www.freelancer.com/freelancers/skills/web-scraping
````

#### Maximum profiles

`maxItems` is the total profile limit across all skills and URLs.
Use a small number for tests.
Use a larger number for sourcing or market mapping.

#### Maximum pages per search

`maxPagesPerSearch` controls pagination depth for each search target.
The actor follows the directory "Next" link until it reaches this limit or `maxItems`.

#### Proxy configuration

The default input does not use a proxy.
If your runs are blocked from your environment, enable Apify Proxy.
Datacenter proxy is usually the cheapest first option.
Residential proxy should only be used when necessary.

### Example input

```json
{
  "skills": ["web scraping", "python"],
  "maxItems": 50,
  "maxPagesPerSearch": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

### Example output

```json
{
  "profileUrl": "https://www.freelancer.com/u/example",
  "username": "example",
  "displayName": "example",
  "title": "Top rated automation developer",
  "country": "Pakistan",
  "location": "Pakistan",
  "avatarUrl": "https://cdn6.f-cdn.com/.../profile_logo.jpg",
  "rating": 5,
  "reviewsCount": 9,
  "hourlyRate": 40,
  "hourlyRateCurrency": "USD",
  "earningsScore": 7.8,
  "skills": ["JavaScript", "Python", "Web Scraping"],
  "summary": "Public profile summary text...",
  "isOnline": true,
  "rankingPosition": 1,
  "sourceUrl": "https://www.freelancer.com/freelancers/skills/web-scraping",
  "scrapedAt": "2026-05-31T00:00:00.000Z"
}
```

### Tips for best results

Use specific skill names instead of broad terms.
Start with 25 to 50 profiles to validate the output.
Use direct start URLs for exact Freelancer.com category pages.
Increase pagination only when you need deeper results.
Check the `sourceUrl` field when combining multiple skills.

### Common use cases

Build a shortlist of web scraping freelancers.
Compare hourly rates across skills.
Track supply for outsourcing categories.
Find agencies or teams active in a niche.
Create a repeatable freelancer market dataset.
Enrich sourcing workflows with public profile links.

### Integrations

Export results to Google Sheets for recruiting workflows.
Send dataset rows to Make or Zapier for CRM enrichment.
Use Apify webhooks to trigger downstream processing.
Load CSV exports into Airtable or Notion.
Analyze hourly rates and countries in BI tools.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/freelancer-profiles-scraper').call({
  skills: ['web scraping'],
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/freelancer-profiles-scraper').call(run_input={
    'skills': ['web scraping'],
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~freelancer-profiles-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"skills":["web scraping"],"maxItems":25}'
```

### MCP integration

Use this actor from MCP-compatible tools via the Apify MCP server.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/freelancer-profiles-scraper
```

Add the Apify MCP server in Claude Code:

```bash
claude mcp add --transport http apify https://mcp.apify.com/?tools=automation-lab/freelancer-profiles-scraper
```

Claude Desktop JSON configuration example:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/freelancer-profiles-scraper"
    }
  }
}
```

Example prompts showing MCP usage:

```text
Use the Apify MCP tool `automation-lab/freelancer-profiles-scraper` to find 40 Freelancer.com profiles for React developers in Europe, then summarize common skills and hourly rate bands.
```

```text
Run automation-lab/freelancer-profiles-scraper through MCP for the skill web scraping and compare public profile locations, review counts, and earnings signals.
```

```text
Using MCP, collect 50 Freelancer.com Python profiles with automation-lab/freelancer-profiles-scraper and identify common skills and rate ranges.
```

### Data quality notes

The actor extracts data shown in public directory HTML.
Some fields may be missing when Freelancer.com does not show them for a profile.
Profile detail pages are not fetched in the MVP, which keeps the actor faster and cheaper.
Directory cards can change over time, so field availability may vary.

### Legality and ethics

This actor is intended for public web data.
You are responsible for using the data in compliance with applicable laws and platform terms.
Do not use scraped contact or profile data for spam, harassment, or prohibited profiling.
Respect privacy laws and internal compliance requirements.

### FAQ

#### Does this actor scrape private Freelancer.com data?

No. It only reads public directory pages accessible without logging in.

#### Why did a run return fewer profiles than requested?

The selected skill may have fewer visible profiles, pagination may be limited, or the site may have returned a blocked/empty page.
Try another skill, direct start URL, or proxy configuration.

#### Does it scrape project/job listings?

No. This actor is scoped to freelancer profile directory results.
Use a project/job scraper for Freelancer.com project listings.

#### Can I scrape profile detail pages?

The current version focuses on search/profile-card data only.
This keeps runs lightweight and avoids unnecessary requests.

#### What if Freelancer.com blocks my request?

Enable Apify Proxy in the input.
Try datacenter proxy first for cost control.
Use residential proxy only if cheaper options do not work.

### Related scrapers

- https://apify.com/automation-lab/freelancer-jobs-scraper
- https://apify.com/automation-lab/upwork-jobs-scraper
- https://apify.com/automation-lab/indeed-scraper
- https://apify.com/automation-lab/linkedin-jobs-scraper

### Changelog

Initial version extracts public Freelancer.com freelancer directory cards by skill and start URL.

### Support

If you need a field that is visible on Freelancer.com but missing from the output, open an issue on the Apify actor page.
Include the input you used and a sample Freelancer.com URL.

### Implementation summary

The actor uses HTTP requests and Cheerio parsing.
It does not run a browser.
It follows Freelancer.com directory pagination.
It deduplicates profiles by profile URL.
It charges one `profile` event per saved dataset item.

### Output reliability checklist

Profile URLs are absolute.
Numeric fields are parsed as numbers.
Skills are saved as an array.
Timestamps use ISO format.
Source URLs are retained for auditability.

### Version

Current version: 0.1.

### Lines for store completeness

This section intentionally keeps the README detailed for Apify Store visitors.
It explains use cases, inputs, outputs, API usage, MCP usage, pricing, legality, and troubleshooting.
The actor is best for public Freelancer.com directory research.
The actor is not a private account scraper.
The actor is not a messaging automation tool.
The actor is not a job/project listing scraper.
Use it for profile discovery and market analysis.
Use exports for downstream workflows.
Use smaller runs when testing.
Use larger runs when scaling a validated workflow.
Check the dataset preview after each new skill.
Keep input skills focused.
Prefer direct start URLs for exact pages.
Review local laws before processing personal data.
Respect Freelancer.com terms.
Store only data you have a legitimate reason to process.
Delete data when it is no longer needed.
Contact support with reproducible examples.

# Actor input Schema

## `skills` (type: `array`):

Freelancer.com skill names to convert into public directory URLs, for example Web Scraping or Python.

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

Optional Freelancer.com freelancer directory URLs such as https://www.freelancer.com/freelancers/skills/web-scraping.

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

Maximum number of freelancer profile cards to save.

## `maxPagesPerSearch` (type: `integer`):

How many directory pages to follow for each start URL or skill.

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

Use Apify Proxy if Freelancer.com blocks direct requests from your location. Datacenter proxy is usually enough for this HTTP scraper.

## Actor input object example

```json
{
  "skills": [
    "web scraping"
  ],
  "startUrls": [
    {
      "url": "https://www.freelancer.com/freelancers/skills/web-scraping"
    }
  ],
  "maxItems": 20,
  "maxPagesPerSearch": 2,
  "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 = {
    "skills": [
        "web scraping"
    ],
    "startUrls": [
        {
            "url": "https://www.freelancer.com/freelancers/skills/web-scraping"
        }
    ],
    "maxItems": 20,
    "maxPagesPerSearch": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/freelancer-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 = {
    "skills": ["web scraping"],
    "startUrls": [{ "url": "https://www.freelancer.com/freelancers/skills/web-scraping" }],
    "maxItems": 20,
    "maxPagesPerSearch": 2,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/freelancer-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 '{
  "skills": [
    "web scraping"
  ],
  "startUrls": [
    {
      "url": "https://www.freelancer.com/freelancers/skills/web-scraping"
    }
  ],
  "maxItems": 20,
  "maxPagesPerSearch": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/freelancer-profiles-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Freelancer Profiles Scraper",
        "description": "Scrape public Freelancer.com freelancer profiles by skill or directory URL. Extract rates, ratings, reviews, skills, summaries, and metadata.",
        "version": "0.1",
        "x-build-id": "o1cUzb84aTp0qfThY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~freelancer-profiles-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-freelancer-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/automation-lab~freelancer-profiles-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-freelancer-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/automation-lab~freelancer-profiles-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-freelancer-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": {
                    "skills": {
                        "title": "Skills / keywords",
                        "type": "array",
                        "description": "Freelancer.com skill names to convert into public directory URLs, for example Web Scraping or Python.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional Freelancer.com freelancer directory URLs such as https://www.freelancer.com/freelancers/skills/web-scraping.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum profiles",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of freelancer profile cards to save.",
                        "default": 20
                    },
                    "maxPagesPerSearch": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many directory pages to follow for each start URL or skill.",
                        "default": 2
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use Apify Proxy if Freelancer.com blocks direct requests from your location. Datacenter proxy is usually enough for this HTTP scraper."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
