# Freelancer Jobs Scraper (`automation-lab/freelancer-jobs-scraper`) Actor

Scrape public Freelancer.com projects and job listings by keyword, category, budget, bids, skills, and recency for lead generation.

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

Scrape public Freelancer.com project and job listings from search, skill, and category pages.

Use this actor when you need structured freelance lead data from Freelancer.com without manually opening dozens of search pages.

### What does Freelancer Jobs Scraper do?

Freelancer Jobs Scraper extracts public project cards from Freelancer.com job listing pages.

It saves one dataset row per project.

Each row can include the project title, URL, description preview, visible budget, parsed budget range, bid count, time-left label, skill tags, source URL, and scrape timestamp.

The actor is designed for public search pages such as:

- `https://www.freelancer.com/jobs/`
- `https://www.freelancer.com/jobs/python/`
- `https://www.freelancer.com/jobs/web-scraping/`
- Freelancer search URLs generated from keywords

### Who is it for?

This actor is useful for teams that monitor freelance project demand.

- 🧑‍💼 Agencies can find new clients looking for specific services.
- 🧑‍💻 Freelancers can track projects in their niche.
- 📈 Market researchers can measure demand for skills and categories.
- 🧲 Sales teams can discover public project leads.
- 🧪 Product teams can watch emerging service requests.
- 📊 Analysts can export recurring job-market snapshots.

### Why use this actor?

Freelancer.com has many public project listings, but manual monitoring is slow.

This actor turns those pages into a structured dataset.

You can run it on a schedule, export results, connect it to automations, or call it from your own application.

### What data can you extract?

The actor extracts the fields visible on public listing cards.

| Field | Description |
| --- | --- |
| `title` | Project title shown on Freelancer |
| `url` | Absolute project URL |
| `projectId` | Project URL slug |
| `description` | Listing-card description preview |
| `budget` | Raw visible budget or hourly rate text |
| `currency` | Parsed currency symbol or code |
| `minBudget` | Parsed lower budget value |
| `maxBudget` | Parsed upper budget value |
| `budgetType` | `fixed`, `hourly`, or `unknown` |
| `averageBid` | Parsed visible average bid when Freelancer shows it |
| `bidCount` | Visible number of bids |
| `timeLeft` | Time-left label shown on the card |
| `skills` | Public skill tags |
| `categorySlug` | Category segment from project URL |
| `sourceUrl` | Search/listing page that produced the row |
| `scrapedAt` | ISO timestamp when the row was saved |

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

The actor uses pay-per-event pricing.

You pay a small start fee per run and a per-result fee for each Freelancer project saved.

Platform pricing uses the minimum accepted tier floor: BRONZE is `$0.10 per 1,000 saved listings`, with lower prices on higher Apify tiers, plus a `$0.005` run-start event.

Actual Store pricing is shown on the Apify actor page before you start a run.

### How to scrape Freelancer jobs

1. Open the actor on Apify.
2. Add one or more Freelancer job URLs, keywords, or category slugs.
3. Set `maxItems` to the number of projects you need.
4. Optionally set budget filters.
5. Click **Start**.
6. Export the dataset as JSON, CSV, Excel, XML, or RSS.

### Input options

You can use three discovery modes together.

#### Start URLs

Use direct Freelancer URLs when you already know the page you want.

Example:

```json
{
  "startUrls": [{ "url": "https://www.freelancer.com/jobs/python/" }],
  "maxItems": 25
}
````

#### Keywords

Use keywords to generate Freelancer job-category URLs. For example, `web scraping` becomes `/jobs/web-scraping/`.

Example:

```json
{
  "keywords": ["web scraping", "shopify"],
  "maxItems": 50
}
```

#### Category slugs

Use category slugs from Freelancer URLs.

Example:

```json
{
  "categorySlugs": ["python", "web-scraping", "data-entry"],
  "maxItems": 100
}
```

### Output example

```json
{
  "title": "Python Web Scraping Project",
  "url": "https://www.freelancer.com/projects/python/example-project",
  "projectId": "example-project",
  "description": "I need a Python developer to collect public data...",
  "budget": "$250 - $750",
  "currency": "$",
  "minBudget": 250,
  "maxBudget": 750,
  "budgetType": "fixed",
  "averageBid": null,
  "bidCount": 12,
  "timeLeft": "6 days left",
  "skills": ["Python", "Web Scraping", "Data Mining"],
  "categorySlug": "python",
  "sourceUrl": "https://www.freelancer.com/jobs/python/",
  "scrapedAt": "2026-05-30T08:00:00.000Z"
}
```

### Tips for better results

- Start with a small `maxItems` value to verify your query.
- Use category slugs for cleaner niche-specific results.
- Use broad keywords if a specific keyword returns too few listings.
- Leave proxy disabled unless you see blocking.
- Schedule recurring runs to build a time series of demand.
- Use budget filters after you confirm the source page has enough results.

### Budget filtering

The actor parses visible budget text from listing cards.

For example, `$250 - $750` becomes `minBudget: 250` and `maxBudget: 750`.

`minBudget` keeps projects whose parsed maximum is at least your threshold.

`maxBudget` keeps projects whose parsed minimum is no more than your threshold.

Budget parsing is best-effort because the source page controls the text format.

### Proxy settings

Freelancer public job pages usually work without proxy.

If your environment receives blocks, enable `useProxy`.

You can optionally set `proxyGroups` such as `SHADER`.

Residential proxies are not the default because they cost more.

### Scheduling workflows

Run the actor daily or hourly to monitor new project demand.

Common schedules include:

- Daily agency lead list for one category.
- Hourly alerts for urgent keywords.
- Weekly market snapshot for pricing research.
- Monthly skill-demand export for reports.

### Integrations

You can connect the dataset to downstream tools.

- 📬 Send new matching projects to Slack or email.
- 🧾 Export CSV files to Google Sheets.
- 🧠 Feed listings into lead scoring workflows.
- 🔎 Monitor demand for a niche over time.
- 🧩 Combine with CRM enrichment tools.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/freelancer-jobs-scraper').call({
  categorySlugs: ['python'],
  maxItems: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/freelancer-jobs-scraper').call(run_input={
    'keywords': ['web scraping'],
    'maxItems': 25,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~freelancer-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"categorySlugs":["python"],"maxItems":25}'
```

### MCP usage

You can use this actor from Apify MCP tools in Claude Code, Claude Desktop, or other MCP-compatible clients.

Use an MCP URL that includes this actor as an enabled tool:

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

Claude Code setup example:

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

Claude Desktop JSON configuration example:

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

Example prompts:

- "Scrape 25 Python projects from Freelancer and summarize the budgets."
- "Find Freelancer jobs for web scraping and group them by skill tags."
- "Run the Freelancer Jobs Scraper daily and alert me about projects over $500."

### Data quality notes

The actor extracts public listing-card data.

It does not log in.

It does not scrape private messages.

It does not guarantee fields that are not visible in the public HTML.

Descriptions are previews from search result cards, not full private project documents.

### Legality

This actor is intended to extract publicly available information from Freelancer.com listing pages.

You are responsible for using the data in compliance with applicable laws, Freelancer.com's terms, privacy rules, and your own data-processing obligations.

Avoid collecting or using personal data in ways that violate privacy, anti-spam, or platform rules.

### FAQ

#### Is this an official Freelancer.com API?

No. This actor extracts public listing-card data from Freelancer.com pages. It is not affiliated with Freelancer.com.

#### Can it scrape full private project details?

No. The v0.1 actor focuses on public search/listing cards and does not log in or access private pages.

### Troubleshooting

#### Why did I get fewer results than `maxItems`?

The source may have fewer public listings for your query, or your budget filters may remove many rows.

Try a broader keyword or a category URL.

#### Why are some budgets null?

Some listing cards may not show a standard budget format.

The actor keeps the raw `budget` text when visible and uses best-effort parsing for numeric fields.

#### Should I enable proxy?

Start without proxy.

Enable proxy only if requests are blocked or return empty pages unexpectedly.

### Related scrapers

Other automation-lab actors may help with adjacent workflows:

- `https://apify.com/automation-lab/indeed-scraper`
- `https://apify.com/automation-lab/google-maps-scraper`
- `https://apify.com/automation-lab/linkedin-jobs-scraper`
- `https://apify.com/automation-lab/upwork-jobs-scraper`

### Changelog

#### 0.1

Initial version.

- Public Freelancer job listings.
- Keyword, category slug, and direct URL inputs.
- Budget parsing.
- Skill tags.
- Optional proxy support.

### Support

If a run fails, include the run URL and input when reporting the issue.

Small reproducible examples are the fastest to debug.

### Summary

Freelancer Jobs Scraper gives you structured, exportable Freelancer.com public project listings for lead generation, research, and market monitoring.

# Actor input Schema

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

Optional Freelancer.com jobs/search/category URLs. If no URLs, keywords, or category slugs are supplied, the actor scrapes https://www.freelancer.com/jobs/.

## `keywords` (type: `array`):

Free-text keywords converted into Freelancer jobs slugs, such as Python, web scraping, Shopify, or logo design.

## `categorySlugs` (type: `array`):

Freelancer job category or skill slugs from URLs, for example python, web-scraping, graphic-design, data-entry.

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

Maximum number of Freelancer project/job listings to save.

## `minBudget` (type: `integer`):

Optional client-side filter. Keeps projects whose parsed max budget is at least this number.

## `maxBudget` (type: `integer`):

Optional client-side filter. Keeps projects whose parsed min budget is no more than this number.

## `includeDescription` (type: `boolean`):

Save the listing description preview shown on Freelancer job search pages.

## `useProxy` (type: `boolean`):

Enable Apify Proxy if your runs are blocked. Public Freelancer listing pages usually work without proxy.

## `proxyGroups` (type: `array`):

Optional Apify Proxy groups to use when proxy is enabled, for example SHADER. Leave empty for automatic proxy selection.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.freelancer.com/jobs/python/"
    }
  ],
  "keywords": [
    "web scraping"
  ],
  "categorySlugs": [
    "python"
  ],
  "maxItems": 20,
  "includeDescription": true,
  "useProxy": false,
  "proxyGroups": []
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.freelancer.com/jobs/python/"
        }
    ],
    "keywords": [
        "web scraping"
    ],
    "categorySlugs": [
        "python"
    ],
    "maxItems": 20
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Freelancer Jobs Scraper",
        "description": "Scrape public Freelancer.com projects and job listings by keyword, category, budget, bids, skills, and recency for lead generation.",
        "version": "0.1",
        "x-build-id": "yIdtUPX4nCPcxvhIR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~freelancer-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-freelancer-jobs-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-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-freelancer-jobs-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-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-freelancer-jobs-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": {
                    "startUrls": {
                        "title": "Freelancer jobs URLs",
                        "type": "array",
                        "description": "Optional Freelancer.com jobs/search/category URLs. If no URLs, keywords, or category slugs are supplied, the actor scrapes https://www.freelancer.com/jobs/.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Free-text keywords converted into Freelancer jobs slugs, such as Python, web scraping, Shopify, or logo design.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categorySlugs": {
                        "title": "Skill/category slugs",
                        "type": "array",
                        "description": "Freelancer job category or skill slugs from URLs, for example python, web-scraping, graphic-design, data-entry.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum projects",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Freelancer project/job listings to save.",
                        "default": 50
                    },
                    "minBudget": {
                        "title": "Minimum budget",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional client-side filter. Keeps projects whose parsed max budget is at least this number."
                    },
                    "maxBudget": {
                        "title": "Maximum budget",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional client-side filter. Keeps projects whose parsed min budget is no more than this number."
                    },
                    "includeDescription": {
                        "title": "Include descriptions",
                        "type": "boolean",
                        "description": "Save the listing description preview shown on Freelancer job search pages.",
                        "default": true
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Enable Apify Proxy if your runs are blocked. Public Freelancer listing pages usually work without proxy.",
                        "default": false
                    },
                    "proxyGroups": {
                        "title": "Proxy groups",
                        "type": "array",
                        "description": "Optional Apify Proxy groups to use when proxy is enabled, for example SHADER. Leave empty for automatic proxy selection.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
