# Remotive Jobs Scraper (`fetch_cat/remotive-jobs-scraper`) Actor

Search public Remotive remote jobs by keyword, category, company, candidate location, salary text, and age. Export companies, roles, tags, descriptions, publication dates, and source URLs.

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

## Pricing

from $0.02 / 1,000 result extracteds

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

## Remotive Jobs Scraper

Find, filter, and export public remote job listings from Remotive in a clean dataset.

The Remotive Jobs Scraper helps recruiters, job aggregators, analysts, and GTM teams track remote roles by keyword, category, company, location, salary text, and publication date.

It returns structured job records that are easy to export to CSV, JSON, Excel, Google Sheets, Airtable, or your own database.

### Scrape Remotive remote jobs by keyword, category, company, and location

This actor collects public remote job listings from Remotive and saves them as structured records.

Use it to:

- 🔎 Search jobs by keyword such as `python`, `product manager`, or `customer support`
- 🧭 Filter by Remotive category
- 🏢 Narrow results to a specific company
- 🌍 Match candidate location text such as `Worldwide`, `Europe`, or `Americas`
- 🕒 Keep only recently published jobs
- 📄 Export clean description text, with optional original HTML
- 🔗 Preserve the Remotive listing URL on every item

### Who is it for?

#### Recruiters

Track new remote roles in your niche and monitor which companies are hiring.

#### Job board operators

Build internal job intelligence workflows from public listings while keeping the original Remotive URL for attribution.

#### Market researchers

Analyze remote-work demand by category, company, location, and skill tags.

#### Sales and GTM teams

Find companies actively hiring for roles that signal budget, growth, or technology needs.

#### Developers and data teams

Automate scheduled remote-job exports without maintaining scraping infrastructure.

### Why use this actor?

- ⚡ Fast API-first collection for public Remotive listings
- 🧹 Clean, normalized output fields
- 📦 Works well with scheduled runs and exports
- 💸 Low-cost pay-per-result pricing
- 🧾 Source URLs preserved for every job
- 🛠️ Simple inputs that are easy to automate

### Remotive fields you can export

| Field | Description |
| --- | --- |
| `id` | Remotive job ID |
| `title` | Job title |
| `companyName` | Hiring company name |
| `companyLogoUrl` | Company logo URL when available |
| `category` | Remotive job category |
| `jobType` | Full-time, contract, or other job type text |
| `candidateRequiredLocation` | Candidate location or region requirement |
| `salary` | Salary text when Remotive provides it |
| `publicationDate` | Listing publication date |
| `tags` | Skill and topic tags |
| `descriptionText` | Clean text description |
| `descriptionHtml` | Optional original description HTML |
| `url` | Remotive listing URL |
| `sourceUrl` | Canonical source URL for attribution |
| `fetchedAt` | Timestamp when the actor fetched the job |

### Use as an RSS feed

You can turn the latest dataset items from a saved Apify task into an RSS feed. Create an actor task with your preferred input, then use the task's last-run dataset endpoint with `format=rss`, `fields`, and `outputFields`:

```text
https://api.apify.com/v2/actor-tasks/[TASK_ID]/runs/last/dataset/items?format=rss&fields=title,url,description,publicationDate&outputFields=title,link,description,pubDate&token=[APIFY_TOKEN]
````

Use the `fields` list to select this actor's dataset columns, and `outputFields` to map them to RSS item fields such as `title`, `link`, `description`, and `pubDate`. Keep your Apify API token private; do not embed tokenized feed URLs in public websites, public repositories, or client-side code.

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

This actor uses pay-per-event pricing.

You pay a small start fee and then a per-result fee for each job listing saved.

For example:

- A short test run with 25 jobs is inexpensive.
- A scheduled monitoring run can cap results with the `limit` input.
- Empty-result searches do not create per-result charges because no job rows are saved.

Exact platform pricing is shown on the Apify actor page before you run it.

### How to use Remotive Jobs Scraper

1. Open the actor on Apify.
2. Enter a keyword in **Keyword search**.
3. Optionally add a category, company, candidate location, or max age filter.
4. Set **Maximum jobs** to control output size.
5. Run the actor.
6. Export the dataset as CSV, JSON, Excel, XML, or HTML.

### Example searches

- `python`
- `react developer`
- `product manager`
- `customer support`
- `data engineer`
- `marketing`
- `sales`

### Input configuration

#### Keyword search

Use a keyword or phrase to search public Remotive jobs.

#### Remotive category

Use a category label such as `Software Development`, `Marketing`, `Customer Service`, `Sales`, `Design`, or `Product`.

#### Company filter

Enter a company name to keep only matching companies.

Matching is case-insensitive and partial.

#### Candidate location filter

Enter a region or location term to match against Remotive's candidate required location field.

Examples include:

- `Worldwide`
- `Europe`
- `Americas`
- `United States`

#### Maximum jobs

Use `limit` to cap the number of saved jobs.

#### Maximum listing age

Use `maxAgeDays` to keep only recently published jobs.

#### Include description HTML

By default, the actor returns clean description text.

Turn on `includeDescriptionHtml` if you also need Remotive's original formatted job description HTML.

### Example input

```json
{
  "search": "python",
  "category": "Software Development",
  "candidateLocation": "Europe",
  "limit": 25,
  "maxAgeDays": 30,
  "includeDescriptionHtml": false
}
```

### Example output

```json
{
  "id": 1919266,
  "title": "Senior Independent AI Engineer / Architect",
  "companyName": "A.Team",
  "companyLogoUrl": "https://remotive.com/job/1919266/logo",
  "category": "Software Development",
  "jobType": "contract",
  "candidateRequiredLocation": "Americas, Europe, Israel",
  "salary": "$120 - $170 /hour",
  "publicationDate": "2026-06-16T10:16:11",
  "tags": ["go", "testing"],
  "descriptionText": "Senior Independent AI Engineer / Architect...",
  "url": "https://remotive.com/remote-jobs/software-development/senior-independent-ai-engineer-architect-1919266",
  "sourceUrl": "https://remotive.com/remote-jobs/software-development/senior-independent-ai-engineer-architect-1919266",
  "fetchedAt": "2026-06-20T00:00:00.000Z"
}
```

### Tips for better results

- Start with a broad keyword, then narrow with company or location filters.
- Use `maxAgeDays` for monitoring new jobs only.
- Keep `includeDescriptionHtml` off unless you need formatted descriptions.
- Set a small `limit` for tests and a larger limit for scheduled exports.
- Export to CSV when sharing with recruiters or sales teams.

### Integrations

You can connect the dataset to:

- Google Sheets for recruiting dashboards
- Airtable for job-board operations
- Slack alerts for new remote roles
- CRM enrichment workflows
- BI tools and warehouses for remote-work market analysis
- RSS/API exports for job boards and newsletters
- Apify schedules, webhooks, MCP, Zapier, Make, or n8n for automated downstream processing

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/remotive-jobs-scraper').call({
  search: 'python',
  limit: 25
});

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

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/remotive-jobs-scraper').call(run_input={
    'search': 'python',
    'limit': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~remotive-jobs-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"search":"python","limit":25}'
```

### MCP usage

Use this actor through the Apify MCP server with Claude Code, Claude Desktop, or other MCP-compatible tools.

MCP server URL:

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

Claude Code setup:

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

Claude Desktop JSON config:

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

Example prompts:

- "Find 25 recent remote Python jobs on Remotive."
- "Export remote product manager roles in Europe."
- "Monitor new customer support jobs from Remotive and summarize companies hiring."

### Scheduling

Set up a recurring schedule on Apify to monitor new remote jobs daily or weekly.

Recommended scheduled input:

```json
{
  "search": "data engineer",
  "limit": 100,
  "maxAgeDays": 7
}
```

### Data quality notes

Remotive controls the original listing content.

Some fields can be empty when the original job does not provide them.

Salary is text, not a normalized numeric range, because job postings use different formats.

Tags are returned exactly as available from the listing source.

### Legality and responsible use

This actor collects public job listings from Remotive and keeps source URLs in the output.

Use the data responsibly.

Do not present Remotive jobs as your own original listings.

Respect Remotive's notices and link users back to the source job page when appropriate.

### Troubleshooting

#### Why did I get zero results?

Your keyword, category, company, location, or max-age filters may be too narrow.

Try removing filters or increasing the listing age window.

#### Why are fewer jobs returned than my limit?

The source may have fewer public matching jobs than your requested limit.

The actor saves all matching public jobs it receives up to the limit.

#### Why is salary missing?

Not every Remotive job includes salary text.

When salary is not available, the output uses `null`.

### Related actors

- [RemoteOK Jobs Scraper](https://apify.com/fetch_cat/remoteok-jobs-scraper) for another remote-job source.
- [LinkedIn Jobs Scraper](https://apify.com/fetch_cat/linkedin-jobs-scraper) for broader public job postings.
- [Greenhouse Jobs Scraper](https://apify.com/fetch_cat/greenhouse-jobs-scraper) for company ATS boards.
- [Y Combinator Companies Scraper](https://apify.com/fetch_cat/y-combinator-companies-scraper) for startup lead lists and hiring flags.
- [Web Page to Markdown Extractor](https://apify.com/fetch_cat/web-page-to-markdown-extractor) for downstream description or page enrichment.

### FAQ

#### Can I filter Remotive jobs by candidate location?

Yes. Use `candidateLocation` to match public candidate-location text such as `Worldwide`, `Europe`, `Americas`, or `United States`.

#### Can I collect clean text descriptions instead of HTML?

Yes. Clean description text is included by default. Enable `includeDescriptionHtml` only when you also need the original formatted HTML.

#### Can I monitor only recently published Remotive jobs?

Yes. Use `maxAgeDays` with an Apify schedule to collect recent public listings for daily or weekly monitoring.

#### Can I filter by company?

Yes. Use the `company` input to keep jobs whose company name contains your filter text.

#### Can I export descriptions?

Yes. Clean description text is always included. Original HTML is optional.

#### Does this actor need a proxy?

No proxy input is required for normal use.

#### Can I run it on a schedule?

Yes. Use Apify schedules with `maxAgeDays` to monitor fresh listings.

#### Can I enrich jobs in another system?

Yes. Export the dataset or consume it through the Apify API.

# Actor input Schema

## `search` (type: `string`):

Keyword or phrase to search for in Remotive job listings, for example Python, product manager, or customer support.

## `category` (type: `string`):

Optional Remotive category such as Software Development, Marketing, Customer Service, Sales, Design, or Product.

## `company` (type: `string`):

Optional company name filter. Matching is case-insensitive and partial.

## `candidateLocation` (type: `string`):

Optional location or region text to match against Remotive's candidate required location field, for example Europe or Worldwide.

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

Maximum number of matching Remotive jobs to save.

## `maxAgeDays` (type: `integer`):

Only save jobs published within this many days. Leave empty to include all matching public listings.

## `includeDescriptionHtml` (type: `boolean`):

When enabled, output includes Remotive's original HTML description in addition to clean description text.

## Actor input object example

```json
{
  "search": "software",
  "limit": 10,
  "includeDescriptionHtml": 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 = {
    "search": "software",
    "limit": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/remotive-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 = {
    "search": "software",
    "limit": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/remotive-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 '{
  "search": "software",
  "limit": 10
}' |
apify call fetch_cat/remotive-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Remotive Jobs Scraper",
        "description": "Search public Remotive remote jobs by keyword, category, company, candidate location, salary text, and age. Export companies, roles, tags, descriptions, publication dates, and source URLs.",
        "version": "0.1",
        "x-build-id": "5RIaB3lW1hICib2IH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~remotive-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-remotive-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~remotive-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-remotive-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~remotive-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-remotive-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": {
                    "search": {
                        "title": "Keyword search",
                        "type": "string",
                        "description": "Keyword or phrase to search for in Remotive job listings, for example Python, product manager, or customer support."
                    },
                    "category": {
                        "title": "Remotive category",
                        "type": "string",
                        "description": "Optional Remotive category such as Software Development, Marketing, Customer Service, Sales, Design, or Product."
                    },
                    "company": {
                        "title": "Company filter",
                        "type": "string",
                        "description": "Optional company name filter. Matching is case-insensitive and partial."
                    },
                    "candidateLocation": {
                        "title": "Candidate location filter",
                        "type": "string",
                        "description": "Optional location or region text to match against Remotive's candidate required location field, for example Europe or Worldwide."
                    },
                    "limit": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of matching Remotive jobs to save.",
                        "default": 50
                    },
                    "maxAgeDays": {
                        "title": "Maximum listing age in days",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Only save jobs published within this many days. Leave empty to include all matching public listings."
                    },
                    "includeDescriptionHtml": {
                        "title": "Include description HTML",
                        "type": "boolean",
                        "description": "When enabled, output includes Remotive's original HTML description in addition to clean description text.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
