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

Scrape public Freelancer.com project listings by keyword, category, or URL. Extract budgets, bids, skills, time left, and verified-payment signals.

- **URL**: https://apify.com/fetch\_cat/freelancer-jobs-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.21 / 1,000 project listings

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 Jobs & Projects Scraper

Monitor public Freelancer.com projects, collect fresh job leads, and export structured project data for sales, research, sourcing, and market analysis.

Freelancer.com Jobs & Projects Scraper turns public Freelancer project posts into clean dataset rows with titles, URLs, budgets, skills, dates, descriptions, and optional detail-page signals such as bids. Use it to watch demand for services, find projects matching your skills, research pricing trends, or build lead pipelines from fresh public marketplace activity.

### What does Freelancer.com Jobs & Projects Scraper do?

This actor collects public Freelancer.com project listings and saves each project as a structured record.

It can:

- 🔎 Collect newest public Freelancer projects
- 🧠 Filter projects by keywords such as `shopify`, `python`, or `data entry`
- 🛠️ Filter by skill/category names such as `Web Scraping`, `WordPress`, or `Graphic Design`
- 💰 Parse visible budget text into normalized budget fields where possible
- 🌐 Accept direct Freelancer jobs, category, feed, or project URLs
- 📄 Optionally open public project detail pages for extra visible fields
- 📦 Export results as JSON, CSV, Excel, XML, or through the Apify API

### Who is it for?

Freelancers use it to track new projects that match their skill stack.

Agencies use it to monitor buying intent for services they sell.

Lead-generation teams use it to build lists of public project opportunities.

Market researchers use it to study service demand, skills, budgets, and posting volume.

Product teams use it to observe what businesses are outsourcing in a niche.

Recruiters and talent platforms use it to understand freelance work trends.

### Why use this scraper?

Manual Freelancer.com monitoring is repetitive. Search pages change quickly, and fresh projects can be missed if you only check once per day.

This actor helps you:

- Save time on daily marketplace checks
- Build repeatable monitoring workflows
- Compare project budgets across skills
- Discover current service demand
- Export data into spreadsheets or BI tools
- Trigger automations from new project records
- Keep a historical dataset of public project posts

### What data can you extract?

Each dataset row represents one public Freelancer.com project or job post.

| Field | Description |
| --- | --- |
| `title` | Project title |
| `url` | Freelancer project URL |
| `projectId` | Parsed project ID when available |
| `description` | Public project summary |
| `budgetText` | Original visible budget text |
| `currency` | Parsed currency symbol or code |
| `budgetMin` | Parsed lower budget value |
| `budgetMax` | Parsed upper budget value |
| `budgetType` | Fixed, hourly, or contest when detectable |
| `skills` | Skills/tags attached to the project |
| `categories` | Category labels from the source |
| `publishedAt` | Public posting date when available |
| `source` | Source URL used for discovery |
| `isFeatured` | Detail-page flag when visible |
| `isGuaranteed` | Detail-page flag when visible |
| `bidsCount` | Visible bid count when detail pages are enabled |
| `averageBidText` | Visible average bid text when detail pages are enabled |
| `scrapedAt` | Timestamp when the record was saved |

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

The actor uses pay-per-event pricing. You pay a small run-start charge and then a per-project charge for saved dataset records.

For typical monitoring runs, keep `maxItems` close to the number of leads you need. Start with 25 or 50 projects, verify the output, and then increase the limit for recurring workflows.

Current pricing:

- Run start: `$0.005`
- Saved project (BRONZE): `$0.0001` per item
- Saved project (SILVER): `$0.000078` per item
- Saved project (GOLD): `$0.00006` per item
- Saved project (PLATINUM): `$0.00004` per item
- Saved project (DIAMOND): `$0.000028` per item

### How to use it

1. Open the actor on Apify.
2. Enter optional keywords such as `python`, `seo`, `shopify`, or `data entry`.
3. Enter optional Freelancer skill/category names.
4. Set `maxItems` to the number of project records you want.
5. Optionally add Freelancer.com start URLs.
6. Leave detail pages disabled for faster monitoring, or enable them when you need bid-related fields.
7. Run the actor.
8. Download the dataset or connect it to your automation.

### Input options

#### Keywords

Use keywords to match text in project titles, descriptions, skills, and categories.

Examples:

- `shopify`
- `lead generation`
- `python`
- `data entry`
- `wordpress`

#### Skills / categories

Use skill filters when you want projects tagged with a known Freelancer skill.

Examples:

- `Web Scraping`
- `Python`
- `WordPress`
- `Graphic Design`
- `SEO`

#### Maximum projects

`maxItems` limits how many project rows are saved.

Use a small value for testing and a larger value for scheduled monitoring.

#### Start URLs

You can provide Freelancer.com URLs if you want to focus the run.

Supported examples include:

- `https://www.freelancer.com/rss.xml`
- `https://www.freelancer.com/jobs/`
- Direct public project URLs

If you leave this field empty, the actor collects from the newest public project source.

#### Open project detail pages

Enable `includeDetails` when you need extra visible fields from individual project pages, such as bid count or average bid text.

Keep it disabled for cheaper and faster high-frequency monitoring.

#### Budget filters

Use `minBudget` and `maxBudget` to skip records outside a visible budget range when a budget can be parsed.

### Output example

```json
{
  "title": "Build a Shopify product import tool",
  "url": "https://www.freelancer.com/projects/shopify/...",
  "projectId": "40560249",
  "description": "Need help building an import workflow...",
  "budgetText": "$250 - $750 USD",
  "currency": "USD",
  "budgetMin": 250,
  "budgetMax": 750,
  "budgetType": "fixed",
  "skills": ["Shopify", "JavaScript", "Data Entry"],
  "categories": ["Shopify", "JavaScript", "Data Entry"],
  "publishedAt": "2026-07-04T19:46:21.000Z",
  "source": "https://www.freelancer.com/rss.xml",
  "isFeatured": null,
  "isGuaranteed": null,
  "bidsCount": null,
  "averageBidText": null,
  "scrapedAt": "2026-07-04T20:00:00.000Z"
}
````

### Tips for better results

- Use broad keywords first, then narrow your filters.
- Combine one keyword with one or two skills for focused runs.
- Use `recent` sorting for monitoring fresh projects.
- Use `relevance` sorting when you provide several keywords.
- Keep `includeDetails` off unless you need bid fields.
- Schedule several small focused runs instead of one huge broad run.
- Store historical outputs to compare demand over time.

### Common workflows

#### Freelance opportunity monitoring

Run the actor every hour with your top skills and send matching projects to Slack, Gmail, or a CRM.

#### Agency lead generation

Track projects that mention your services, export leads, and prioritize projects by visible budget.

#### Market research

Collect projects across skills such as design, AI, SEO, and automation to compare budget ranges and demand.

#### Competitive intelligence

Monitor which services businesses are requesting publicly and how requirements change over time.

### Integrations

Use Apify integrations to send project rows to:

- Google Sheets for review queues
- Airtable for lead tracking
- Slack for fresh opportunity alerts
- Zapier or Make for no-code automations
- Webhooks for internal pipelines
- BigQuery or Snowflake for analysis

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/freelancer-jobs-scraper').call({
  keywords: ['shopify'],
  skills: ['Web Scraping'],
  maxItems: 25
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/freelancer-jobs-scraper').call(run_input={
    'keywords': ['python'],
    'skills': ['Automation'],
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~freelancer-jobs-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["wordpress"],"maxItems":25}'
```

### MCP usage

Use this actor from MCP-compatible tools through Apify MCP Server.

MCP URL pattern:

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

Claude Code setup:

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

Claude Desktop JSON config:

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

Example prompts:

- "Find recent Freelancer.com projects about Shopify and summarize the budgets."
- "Collect 25 public projects tagged Web Scraping and create a lead table."
- "Monitor Freelancer.com for WordPress projects and highlight high-budget posts."

### Scheduling

Set up an Apify schedule to run this actor repeatedly.

Recommended schedules:

- Every hour for fresh lead alerts
- Daily for market research snapshots
- Weekly for trend analysis

Use smaller `maxItems` values for frequent schedules and larger limits for weekly research.

### Data quality notes

Freelancer.com project data is public but may vary by project type. Some fields are only available on detail pages. Budget parsing works best when the source exposes a clear numeric range.

If a field is not visible for a project, the actor returns `null` or an empty array instead of inventing data.

### Limits

This actor collects public records only. It does not log in, bid on projects, message users, scrape private dashboards, or bypass access controls.

The actor may return fewer than `maxItems` if your filters are narrow or if there are not enough matching public projects in the current source window.

### FAQ

#### Can I scrape private Freelancer.com projects?

No. This actor is designed for public project pages and public listing data only.

#### Can I schedule this actor for lead monitoring?

Yes. Use an Apify schedule with small focused inputs for regular lead alerts.

### Troubleshooting

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

Your filters may be too narrow. Remove one keyword or skill, increase the time/source coverage with a start URL, or lower budget constraints.

#### Why are bid fields empty?

Bid-related fields are generally collected only when `includeDetails` is enabled and the public project page exposes them.

#### Why is budget parsing incomplete?

Some projects use non-standard budget text, single values, hourly ranges, or localized formats. The original `budgetText` is saved so you can review the source value.

### Legality and responsible use

This actor is designed for public Freelancer.com project information. Use the data responsibly, respect Freelancer.com's terms, and comply with privacy, spam, and outreach laws that apply to your use case.

Do not use scraped data for harassment, unsolicited bulk spam, or attempts to access non-public information.

### Related scrapers

You may also find these Apify actors useful:

- https://apify.com/fetch\_cat/ashby-jobs-scraper
- https://apify.com/fetch\_cat/ats-jobs-scraper
- https://apify.com/fetch\_cat/craigslist-classifieds-scraper
- https://apify.com/fetch\_cat/builtwith-domain-tech-stack-scraper

### Changelog

#### 0.1

Initial version for public Freelancer.com project monitoring with keyword filters, skill filters, budget parsing, and optional detail enrichment.

### Support

If a run fails or returns unexpected results, open an issue with your run URL, input, and a short description of what you expected. Include a sample project URL when possible.

# Actor input Schema

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

Optional words or phrases to match in project titles, descriptions, skills, or categories. Leave empty to collect newest public projects.

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

Optional Freelancer skill or category names to match, such as Web Scraping, Python, WordPress, Graphic Design, or SEO.

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

Maximum number of project records to save.

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

Optional Freelancer.com jobs, RSS, or direct project URLs. If empty, the actor uses the newest public Freelancer projects feed.

## `includeDetails` (type: `boolean`):

Fetch each public project page for extra visible details such as bids and page-level skills. Keep disabled for faster, cheaper monitoring runs.

## `sort` (type: `string`):

Use recent for newest-first source order or relevance to prioritize records matching more filters.

## `minBudget` (type: `number`):

Optional minimum budget filter. Projects with a known maximum budget below this value are skipped.

## `maxBudget` (type: `number`):

Optional maximum budget filter. Projects with a known minimum budget above this value are skipped.

## Actor input object example

```json
{
  "keywords": [],
  "skills": [],
  "maxItems": 20,
  "startUrls": [
    {
      "url": "https://www.freelancer.com/rss.xml"
    }
  ],
  "includeDetails": false,
  "sort": "recent"
}
```

# 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 = {
    "keywords": [],
    "skills": [],
    "maxItems": 20,
    "startUrls": [
        {
            "url": "https://www.freelancer.com/rss.xml"
        }
    ],
    "includeDetails": false,
    "sort": "recent"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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 = {
    "keywords": [],
    "skills": [],
    "maxItems": 20,
    "startUrls": [{ "url": "https://www.freelancer.com/rss.xml" }],
    "includeDetails": False,
    "sort": "recent",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/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 '{
  "keywords": [],
  "skills": [],
  "maxItems": 20,
  "startUrls": [
    {
      "url": "https://www.freelancer.com/rss.xml"
    }
  ],
  "includeDetails": false,
  "sort": "recent"
}' |
apify call fetch_cat/freelancer-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/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 project listings by keyword, category, or URL. Extract budgets, bids, skills, time left, and verified-payment signals.",
        "version": "0.1",
        "x-build-id": "H6ruGS1ZgbO0RMDvf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~freelancer-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-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/fetch_cat~freelancer-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-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/fetch_cat~freelancer-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Optional words or phrases to match in project titles, descriptions, skills, or categories. Leave empty to collect newest public projects.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "skills": {
                        "title": "Skills / categories",
                        "type": "array",
                        "description": "Optional Freelancer skill or category names to match, such as Web Scraping, Python, WordPress, Graphic Design, or SEO.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum projects",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of project records to save.",
                        "default": 20
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional Freelancer.com jobs, RSS, or direct project URLs. If empty, the actor uses the newest public Freelancer projects feed.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "includeDetails": {
                        "title": "Open project detail pages",
                        "type": "boolean",
                        "description": "Fetch each public project page for extra visible details such as bids and page-level skills. Keep disabled for faster, cheaper monitoring runs.",
                        "default": false
                    },
                    "sort": {
                        "title": "Sort mode",
                        "enum": [
                            "recent",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Use recent for newest-first source order or relevance to prioritize records matching more filters.",
                        "default": "recent"
                    },
                    "minBudget": {
                        "title": "Minimum budget",
                        "minimum": 0,
                        "type": "number",
                        "description": "Optional minimum budget filter. Projects with a known maximum budget below this value are skipped."
                    },
                    "maxBudget": {
                        "title": "Maximum budget",
                        "minimum": 0,
                        "type": "number",
                        "description": "Optional maximum budget filter. Projects with a known minimum budget above this value are skipped."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
