# Freelancer.com Project Listings Scraper (`automation-lab/freelancer-project-listings-scraper`) Actor

Scrape Freelancer.com project listings, budgets, skills, bid counts, payment verification, and URLs for lead generation and demand research.

- **URL**: https://apify.com/automation-lab/freelancer-project-listings-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.com Project Listings Scraper

Scrape public Freelancer.com project listings for lead generation, hiring demand research, and marketplace monitoring.

### What does Freelancer.com Project Listings Scraper do?

Freelancer.com Project Listings Scraper extracts public project cards from Freelancer.com jobs pages.
It collects project titles, URLs, descriptions, skills, budgets, bid counts, time-left labels, payment verification signals, source pages, and timestamps.
Use it to monitor active freelance demand without logging in or visiting each category manually.

### Who is it for?

- 🧲 Agencies looking for new client leads in specific service categories.
- 👩‍💻 Freelancers tracking demand for skills such as Python, web scraping, Shopify, data entry, or design.
- 📊 Marketplace analysts measuring budgets and competition by category.
- 🧑‍💼 Recruiters and sales teams building prospect lists from public project demand.
- 🛠️ Tool builders feeding Freelancer.com leads into CRMs, sheets, alerts, or dashboards.

### Why use this scraper?

Freelancer.com pages are useful but repetitive to monitor by hand.
This actor turns public listings into structured data that is easy to filter, enrich, export, and schedule.
You can scrape one category, many categories, or generated query pages in one run.

### What data can you extract?

| Field | Description |
| --- | --- |
| `title` | Project title shown on Freelancer.com |
| `url` | Absolute project URL |
| `description` | Project summary text from the listing card |
| `skills` | Skills and category tags |
| `budgetText` | Budget or average-bid text as displayed |
| `budgetAmount` | Parsed numeric budget / bid amount when available |
| `currency` | Currency symbol/code when detected |
| `bidCount` | Number of bids shown on the listing |
| `averageBidText` | Average-bid display text |
| `timeLeft` | Time remaining label |
| `paymentVerified` | Whether payment verification is visible |
| `sourceUrl` | Result page that produced the listing |
| `sourceQuery` | Query used to generate the source URL, if any |
| `pageNumber` | Pagination page number |
| `scrapedAt` | ISO timestamp for the scrape |

### How much does it cost to scrape Freelancer.com project listings?

The actor uses pay-per-event pricing.
There is a small run-start charge and a per-project-listing charge.
You control cost with `maxItems` and `maxPagesPerSource`.
Start with the default 20 listings, then scale once you confirm the categories you need.

### How to scrape Freelancer.com jobs

1. Open the actor on Apify.
2. Add one or more Freelancer.com jobs URLs such as `https://www.freelancer.com/jobs/python/`.
3. Optionally add search queries such as `web scraping` or `data entry`.
4. Set `maxItems` and `maxPagesPerSource`.
5. Run the actor.
6. Export results as JSON, CSV, Excel, or connect them to an integration.

### Input options

#### Start URLs

Use public Freelancer.com jobs pages.
Examples:

- `https://www.freelancer.com/jobs/python/`
- `https://www.freelancer.com/jobs/web-scraping/`
- `https://www.freelancer.com/jobs/data-entry/`

#### Search queries

Queries are converted to Freelancer.com jobs URL slugs.
For example `web scraping` becomes `/jobs/web-scraping/`.
This is convenient when you want to monitor many skill categories.

#### Maximum project listings

`maxItems` limits the total number of saved listings.
Use a low number for testing and a higher number for scheduled monitoring.

#### Maximum pages per source

`maxPagesPerSource` controls pagination depth for every start URL or query.
Freelancer.com category pages normally expose multiple pages.

#### Proxy configuration

Proxy use is optional.
Leave it disabled for cheap first runs.
Enable Apify Proxy if your network is blocked or you run larger scheduled jobs.

### Output example

```json
{
  "title": "AI for Maritime Safety Intelligence Platform",
  "url": "https://www.freelancer.com/projects/ai-development/for-maritime-safety-intelligence",
  "description": "AI / LLM Engineer Needed...",
  "skills": ["AI Development", "Data Analysis", "Python"],
  "budgetText": "$502 Avg Bid",
  "budgetAmount": 502,
  "currency": "$",
  "bidCount": 133,
  "timeLeft": "6 days left",
  "paymentVerified": true,
  "sourceUrl": "https://www.freelancer.com/jobs/python/",
  "sourceQuery": "python",
  "pageNumber": 1,
  "scrapedAt": "2026-06-24T00:00:00.000Z"
}
````

### Tips for better results

- 🎯 Use specific skill pages for targeted lead lists.
- 📉 Keep default limits low while testing a new category.
- 🧾 Export CSV for sales workflows and JSON for automation.
- 🔁 Schedule daily runs to monitor new opportunities.
- 🧠 Combine skills such as Python, FastAPI, data extraction, and web scraping for a broader lead view.

### Lead generation workflows

Send the dataset to Google Sheets, Airtable, HubSpot, Pipedrive, or a custom webhook.
Filter for budgets, bid counts, payment verification, and relevant skills.
Sales teams can use the source URL and title to qualify projects before outreach.

### Marketplace analytics workflows

Run the actor across the same categories every day.
Track budget changes, project volume, high-demand skills, and bid competition over time.
Analysts can aggregate `budgetAmount`, `bidCount`, and `skills` for category intelligence.

### Freelancer monitoring workflows

Freelancers can schedule this actor for their core skills and receive fresh project leads.
Use Apify integrations or webhooks to notify Slack, email, or a CRM whenever new listings appear.

### 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-project-listings-scraper').call({
  searchQueries: ['python', 'web scraping'],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/freelancer-project-listings-scraper').call(run_input={
    'searchQueries': ['python', 'web scraping'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~freelancer-project-listings-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["python","web scraping"],"maxItems":100}'
```

### MCP integration

Use this actor from Apify MCP in Claude Desktop or Claude Code.
The tool URL is:

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

Add it from Claude Code with:

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

Claude Desktop JSON configuration example:

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

Example prompts:

- "Scrape 100 Python projects from Freelancer.com and summarize the best leads."
- "Find Freelancer.com jobs for web scraping and rank them by budget."
- "Monitor data entry projects and show me payment-verified opportunities."

### Integrations

The actor works with Apify datasets and integrations.
Common patterns include:

- Dataset to Google Sheets for lead review.
- Webhook to Slack for daily opportunity alerts.
- Dataset API to BI tools for marketplace analysis.
- CRM import for agency prospecting.
- MCP workflows for AI-assisted lead qualification.

### Scheduling

Schedule the actor daily or hourly depending on your monitoring needs.
For lead generation, daily runs are often enough.
For competitive freelance categories, shorter intervals may help you react faster.

### Data quality notes

The actor extracts what is visible on public listing cards.
Some fields may be missing when Freelancer.com does not display them.
Budget text is preserved exactly, while `budgetAmount` is a best-effort numeric parse.

### Limitations

- It does not log in to Freelancer.com.
- It does not place bids or contact clients.
- It does not scrape private messages or authenticated project data.
- It focuses on public listing pages, not full detail-page enrichment.

### Troubleshooting

#### Why did I get fewer items than requested?

The chosen category may have fewer visible listings, or pagination may end before your limit.
Increase `maxPagesPerSource` or add more categories.

#### Why are budget fields sometimes null?

Some listings display ranges, hidden budgets, contest details, or average-bid labels.
The raw `budgetText` is kept even when a numeric amount cannot be parsed.

#### Should I enable proxies?

Try without proxies first.
If Freelancer.com blocks your network or you run large jobs, enable Apify Proxy in the input.

### Legality and ethics

This actor extracts publicly visible Freelancer.com listing information.
Use it responsibly, respect Freelancer.com's terms, avoid spam, and comply with privacy, platform, and outreach laws in your jurisdiction.

### Related scrapers

Explore related Automation Lab actors:

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

### Changelog

#### 0.1

Initial private build for public Freelancer.com project listing extraction.

### Support

If a category stops returning results, try a smaller run, enable proxy settings, or provide the source URL and run ID when requesting help.

### FAQ

#### Can I scrape multiple skills at once?

Yes. Add several `searchQueries` or several Freelancer.com jobs URLs.

#### Can I export the results?

Yes. Apify supports JSON, CSV, Excel, XML, RSS, and API exports.

#### Does this actor require a Freelancer.com account?

No. It uses public jobs pages only.

#### Can I scrape more than 100 listings?

Yes. Increase `maxItems` and `maxPagesPerSource`.

#### Is the output suitable for CRM enrichment?

Yes. The actor includes title, URL, skills, budget text, bid count, and source information that can be enriched or qualified downstream.

# Actor input Schema

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

Freelancer.com public jobs pages to scrape. Use category/skill pages such as /jobs/python/ or paginated jobs pages.

## `searchQueries` (type: `array`):

Skill names or category phrases to convert into Freelancer.com jobs URLs, for example Python, web scraping, data entry, or Shopify.

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

Maximum number of Freelancer.com project listings to save across all sources.

## `maxPagesPerSource` (type: `integer`):

How many paginated Freelancer.com result pages to visit per start URL or search query.

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

Optional Apify Proxy settings for larger runs or if Freelancer.com blocks your region. Leave disabled for cheap first runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.freelancer.com/jobs/python/"
    }
  ],
  "searchQueries": [
    "python",
    "web scraping"
  ],
  "maxItems": 20,
  "maxPagesPerSource": 5,
  "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 = {
    "startUrls": [
        {
            "url": "https://www.freelancer.com/jobs/python/"
        }
    ],
    "searchQueries": [
        "python",
        "web scraping"
    ],
    "maxItems": 20,
    "maxPagesPerSource": 5,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/freelancer-project-listings-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/" }],
    "searchQueries": [
        "python",
        "web scraping",
    ],
    "maxItems": 20,
    "maxPagesPerSource": 5,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/freelancer-project-listings-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/"
    }
  ],
  "searchQueries": [
    "python",
    "web scraping"
  ],
  "maxItems": 20,
  "maxPagesPerSource": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/freelancer-project-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Freelancer.com Project Listings Scraper",
        "description": "Scrape Freelancer.com project listings, budgets, skills, bid counts, payment verification, and URLs for lead generation and demand research.",
        "version": "0.1",
        "x-build-id": "i9kVpAo1UYvSyCqtd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~freelancer-project-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-freelancer-project-listings-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-project-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-freelancer-project-listings-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-project-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-freelancer-project-listings-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": "Start URLs",
                        "type": "array",
                        "description": "Freelancer.com public jobs pages to scrape. Use category/skill pages such as /jobs/python/ or paginated jobs pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries / skill slugs",
                        "type": "array",
                        "description": "Skill names or category phrases to convert into Freelancer.com jobs URLs, for example Python, web scraping, data entry, or Shopify.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum project listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Freelancer.com project listings to save across all sources.",
                        "default": 20
                    },
                    "maxPagesPerSource": {
                        "title": "Maximum pages per source",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many paginated Freelancer.com result pages to visit per start URL or search query.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings for larger runs or if Freelancer.com blocks your region. Leave disabled for cheap first runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
