# Remote.com Jobs Scraper (`fetch_cat/remote-dot-com-jobs-scraper`) Actor

Scrape public Remote.com job listings with compensation, departments, locations, seniority, sponsorship flags, quick apply, and apply URLs.

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

## Pricing

from $0.05 / 1,000 job results

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

## Remote.com Jobs Scraper

Collect public Remote.com job listings with company names, departments, locations, seniority, compensation ranges, visa sponsorship flags, quick-apply indicators, and apply links.

Remote.com Jobs Scraper is built for recruiters, job-board operators, HR analysts, and remote-work newsletters that need structured job data from Remote.com without manual copy and paste.

### What does Remote.com Jobs Scraper do?

Remote.com Jobs Scraper extracts structured records from public Remote.com job listings.

It can collect:

- ✅ Job titles
- ✅ Company names
- ✅ Company websites
- ✅ Departments
- ✅ Hiring locations
- ✅ Remote-work type
- ✅ Seniority levels
- ✅ Employment type
- ✅ Travel frequency
- ✅ Compensation minimum and maximum
- ✅ Currency and pay frequency
- ✅ Application deadlines
- ✅ Visa sponsorship availability
- ✅ Quick-apply availability
- ✅ Job URLs
- ✅ Apply URLs
- ✅ Posted and updated dates

### Who is it for?

Remote.com Jobs Scraper is for teams that need structured public job listing data from Remote.com.

### Who is Remote.com Jobs Scraper for?

#### Recruiters

Track new openings from companies hiring through Remote.com.

#### Job-board operators

Use the dataset to enrich remote-work job boards, alerts, and weekly digests.

#### HR analysts

Monitor hiring activity by department, geography, seniority, and salary range.

#### Remote-work newsletters

Find fresh remote roles for curated email issues.

#### Talent intelligence teams

Watch which companies are expanding internationally and what functions they are hiring for.

### Why use this Remote.com job scraper?

Remote.com publishes useful public job-board data, but manually reviewing listings is slow.

This actor turns that public information into a clean dataset that can be exported, filtered, integrated, or scheduled.

Use it when you need repeatable structured data rather than one-off browsing.

### What data can you extract from Remote.com?

| Field | Description |
| --- | --- |
| `title` | Job title |
| `company` | Hiring company name |
| `companyWebsite` | Company website when available |
| `companyLogoUrl` | Company logo URL when available |
| `department` | Department or function |
| `location` | Hiring location or country list |
| `remoteType` | Remote/workplace type |
| `seniority` | Seniority labels |
| `employmentType` | Employment type |
| `travelFrequency` | Travel requirement |
| `deadline` | Application deadline |
| `compensationMin` | Minimum compensation |
| `compensationMax` | Maximum compensation |
| `compensationFrequency` | Pay frequency, such as yearly |
| `currency` | Compensation currency code |
| `currencySymbol` | Currency symbol |
| `visaSponsorshipOffered` | Whether visa sponsorship is offered |
| `quickApply` | Whether quick apply is available |
| `jobUrl` | Remote.com job page |
| `applyUrl` | Apply URL when available |
| `description` | Optional description snippet |
| `postedAt` | Posted date |
| `updatedAt` | Last updated date |
| `source` | Data source name |

### How much does it cost to scrape Remote.com jobs?

This actor uses pay-per-event pricing.

You pay a $0.005 start fee per run and a tiered per-result fee for saved job records. The standard BRONZE per-job price is $0.000077158, with lower per-result prices on higher Apify tiers.

Typical small tests with 25 jobs are inexpensive, and larger scheduled runs scale with the number of jobs saved.

### How to scrape Remote.com jobs

1. Open the actor on Apify.
2. Keep the default start URL or add another Remote.com jobs URL.
3. Add optional filters such as keyword, department, location, or seniority.
4. Set the maximum number of jobs.
5. Click **Start**.
6. Export the dataset as JSON, CSV, Excel, XML, or HTML.

### Input configuration

#### Start URLs

Use Remote.com job listing URLs.

The default is:

```text
https://remote.com/jobs/all
````

#### Keyword search

Use `query` to match text across title, company, department, seniority, and location.

Examples:

- `engineer`
- `sales`
- `finance`
- `customer support`

#### Department filter

Use department names such as:

- Engineering
- Sales
- Marketing
- Customer Support
- IT Services
- Accounts & Finance

#### Location filter

Use country or location text such as:

- United States
- Germany
- South Africa
- Europe
- Canada

#### Seniority filter

Use seniority text such as:

- `entry_level`
- `mid_level`
- `senior`
- `manager`
- `director`

#### Limit

Use `limit` to control the maximum number of jobs saved.

Start small when testing.

#### Include description

Turn on `includeDescription` to fetch a best-effort description snippet from detail pages.

Leave it off for faster large runs.

### Example input

```json
{
  "startUrls": [{ "url": "https://remote.com/jobs/all" }],
  "query": "engineer",
  "location": "United States",
  "limit": 25,
  "includeDescription": false
}
```

### Example output

```json
{
  "title": "Application Support Engineer",
  "company": "Example Company",
  "department": "IT Services",
  "location": "Germany",
  "remoteType": "remote",
  "seniority": ["mid_level"],
  "employmentType": "full_time",
  "deadline": "2026-06-30",
  "compensationMin": 46000,
  "compensationMax": 55000,
  "currency": "EUR",
  "visaSponsorshipOffered": false,
  "quickApply": true,
  "jobUrl": "https://remote.com/jobs/example-job",
  "applyUrl": "https://remote.com/jobs/example-job",
  "postedAt": "2026-06-15T14:19:41Z",
  "updatedAt": "2026-06-15T14:19:41",
  "source": "Remote.com"
}
```

### Tips for better results

- Start with the default all-jobs URL.
- Use a low limit for the first test run.
- Use broad keywords before narrow filters.
- Remove filters if you receive fewer jobs than expected.
- Schedule recurring runs to monitor new openings over time.
- Export CSV for spreadsheets and JSON for pipelines.

### Integrations

Remote.com Jobs Scraper works with Apify integrations and webhooks.

You can:

- Send new jobs to Google Sheets.
- Trigger Slack alerts for matching roles.
- Feed records into Airtable.
- Export JSON to a data warehouse.
- Use Make or Zapier to route matching jobs to newsletters.
- Schedule daily monitoring for specific departments.

### 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/remote-dot-com-jobs-scraper').call({
  startUrls: [{ url: 'https://remote.com/jobs/all' }],
  query: 'engineer',
  limit: 25
});

console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/remote-dot-com-jobs-scraper').call(run_input={
    'startUrls': [{'url': 'https://remote.com/jobs/all'}],
    'query': 'engineer',
    'limit': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~remote-dot-com-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://remote.com/jobs/all"}],"query":"engineer","limit":25}'
```

### MCP usage

Use this actor from Apify MCP-compatible clients.

MCP URL pattern:

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

Add it in Claude Code:

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

Example MCP server JSON configuration:

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

#### Example MCP prompts

MCP example prompts:

Example Claude Code MCP prompt:

```text
Use the Apify MCP Remote.com Jobs Scraper to find engineering roles in Germany and summarize the top companies hiring this week.
```

Example Claude Desktop MCP prompt:

```text
Use MCP to run Remote.com Jobs Scraper for jobs with visa sponsorship and prepare a CSV-ready table with title, company, location, compensation, and apply URL.
```

More prompts you can try:

- "Run Remote.com Jobs Scraper for product roles and create a shortlist of companies with salary ranges."
- "Find Remote.com jobs open to global candidates and group them by department, seniority, and compensation currency."
- "Monitor Remote.com for senior engineering jobs every week and summarize new apply URLs for my recruiting team."

### Scheduling

You can schedule this actor to run daily, weekly, or monthly.

Useful schedules include:

- Daily engineering role monitoring
- Weekly sales and marketing hiring reports
- Monthly compensation trend snapshots
- Newsletter lead collection before publishing day

### Webhooks

Use Apify webhooks to trigger downstream workflows when a run succeeds.

Common webhook actions:

- Send dataset items to a database.
- Notify a Slack channel.
- Start another enrichment actor.
- Update a no-code automation workflow.

### Data quality notes

The actor extracts fields available from public Remote.com job listings.

Some jobs may not include compensation.

Some jobs may not include an external apply URL.

If quick apply is available, the job URL is used as the apply destination.

### FAQ

#### Can I use the API?

Yes. Use the Apify API examples above or connect through Apify MCP.

#### Can I schedule recurring monitoring?

Yes. Schedule the actor daily or weekly and export only the new rows your workflow needs.

### Troubleshooting

#### Why did I get zero results?

Your filters may be too narrow. Remove `query`, `department`, `location`, or `seniority` and try again.

#### Why is compensation empty for some jobs?

Remote.com does not expose a compensation range for every public listing.

#### Why is description empty?

Descriptions are optional and best effort. Turn on `includeDescription` if you need snippets, but keep it off for faster large runs.

### Legality and responsible use

This actor extracts publicly available job listing information.

You are responsible for using the data in compliance with applicable laws, Remote.com terms, and privacy rules.

Do not use scraped data for spam or discriminatory hiring practices.

### Related scrapers

You may also find these Apify actors useful:

- https://apify.com/fetch\_cat/remoteok-jobs-scraper
- https://apify.com/fetch\_cat/ats-jobs-scraper
- https://apify.com/fetch\_cat/lever-jobs-scraper
- https://apify.com/fetch\_cat/workday-jobs-scraper
- https://apify.com/fetch\_cat/ashby-jobs-scraper

### Changelog

#### 0.1

Initial version for public Remote.com job listings.

### Support

If your run fails or you need a field that is visible on Remote.com but missing from the dataset, open an issue from the actor page and include your run ID.

# Actor input Schema

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

Remote.com jobs listing URLs to scrape. Leave the prefilled all-jobs URL to collect from the main public board.

## `query` (type: `string`):

Optional keyword matched against job title, company, department, seniority, and location.

## `department` (type: `string`):

Optional Remote.com department filter, for example Engineering, Sales, Marketing, or Customer Support.

## `location` (type: `string`):

Optional location text filter, for example United States, Germany, South Africa, or Europe.

## `seniority` (type: `string`):

Optional seniority filter such as entry\_level, mid\_level, senior, manager, or director.

## `limit` (type: `integer`):

Maximum number of matching Remote.com jobs to save.

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

Fetch each job detail page and save a best-effort description snippet. Keep off for faster large runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://remote.com/jobs/all"
    }
  ],
  "query": "engineer",
  "limit": 20,
  "includeDescription": 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://remote.com/jobs/all"
        }
    ],
    "query": "engineer",
    "limit": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/remote-dot-com-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://remote.com/jobs/all" }],
    "query": "engineer",
    "limit": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/remote-dot-com-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://remote.com/jobs/all"
    }
  ],
  "query": "engineer",
  "limit": 20
}' |
apify call fetch_cat/remote-dot-com-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Remote.com Jobs Scraper",
        "description": "Scrape public Remote.com job listings with compensation, departments, locations, seniority, sponsorship flags, quick apply, and apply URLs.",
        "version": "0.1",
        "x-build-id": "gVbKpriduw3Lg1cDd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~remote-dot-com-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-remote-dot-com-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~remote-dot-com-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-remote-dot-com-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~remote-dot-com-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-remote-dot-com-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": "Start URLs",
                        "type": "array",
                        "description": "Remote.com jobs listing URLs to scrape. Leave the prefilled all-jobs URL to collect from the main public board.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "query": {
                        "title": "Keyword search",
                        "type": "string",
                        "description": "Optional keyword matched against job title, company, department, seniority, and location."
                    },
                    "department": {
                        "title": "Department",
                        "type": "string",
                        "description": "Optional Remote.com department filter, for example Engineering, Sales, Marketing, or Customer Support."
                    },
                    "location": {
                        "title": "Location / country",
                        "type": "string",
                        "description": "Optional location text filter, for example United States, Germany, South Africa, or Europe."
                    },
                    "seniority": {
                        "title": "Seniority",
                        "type": "string",
                        "description": "Optional seniority filter such as entry_level, mid_level, senior, manager, or director."
                    },
                    "limit": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of matching Remote.com jobs to save.",
                        "default": 50
                    },
                    "includeDescription": {
                        "title": "Include description snippet",
                        "type": "boolean",
                        "description": "Fetch each job detail page and save a best-effort description snippet. Keep off for faster large runs.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
