# Jobicy Remote Jobs Scraper (`fetch_cat/jobicy-remote-jobs-scraper`) Actor

Scrape remote job listings from Jobicy by keyword, category, region, and job type.

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

## Pricing

from $0.02 / 1,000 job listing saveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Jobicy Remote Jobs Scraper

Collect fresh remote job listings from Jobicy and export clean job data to CSV, JSON, Excel, Google Sheets, or your own database.

Use this actor to monitor remote hiring by keyword, industry, region, and job type without building a custom integration. It returns structured listings with company details, job URLs, categories, seniority, publish dates, excerpts, and optional full descriptions.

### At a glance

- **Extracts:** remote job titles, companies, logos, industries, job types, region labels, seniority, publish dates, excerpts, descriptions, and apply URLs.
- **Inputs:** keyword tags, Jobicy category slug, geo/region slug, job type filters, result limit, and description toggle.
- **Best for:** remote job boards, recruiting research, hiring-signal lead generation, job alerts, and labor-market monitoring.
- **Exports:** Apify dataset rows downloadable as CSV, JSON, Excel, XML, RSS, or available through the API.
- **Login:** no Jobicy account is required for public listings.

### Ready-to-run examples

Use these saved Store examples as starting points. Open any example to prefill the Actor input, then adjust URLs, keywords, limits, or filters for your own run.

- **[Export remote jobs with full descriptions](https://apify.com/fetch_cat/jobicy-remote-jobs-scraper/examples/remote-jobs-with-full-descriptions)**
- **[Scrape remote sales jobs in LATAM](https://apify.com/fetch_cat/jobicy-remote-jobs-scraper/examples/remote-sales-jobs-latam)**
- **[Find remote design jobs on Jobicy](https://apify.com/fetch_cat/jobicy-remote-jobs-scraper/examples/remote-design-jobs)**
- **[Scrape remote contract jobs from Jobicy](https://apify.com/fetch_cat/jobicy-remote-jobs-scraper/examples/remote-contract-jobs)**
- **[Scrape remote data science jobs](https://apify.com/fetch_cat/jobicy-remote-jobs-scraper/examples/remote-data-science-jobs)**
- **[Find remote marketing jobs in Europe](https://apify.com/fetch_cat/jobicy-remote-jobs-scraper/examples/remote-marketing-jobs-europe)**
- **[View all ready-to-run examples](https://apify.com/fetch_cat/jobicy-remote-jobs-scraper/examples)** (8 examples)

### What can it do?

- **Find public remote jobs:** collect fresh listings from Jobicy by keyword, category, region, and job type.
- **Capture company context:** save company names, logos, job titles, industries, levels, regions, and apply URLs.
- **Control depth:** include full HTML descriptions only when your workflow needs richer job text.
- **Export clean rows:** send results to CSV, JSON, Excel, XML, RSS, dashboards, or API workflows.
- **Schedule monitoring:** run recurring searches for job-market tracking or hiring-signal alerts.

### Who is it for?

- **Recruiters:** track fresh remote openings in a niche.
- **Job boards and aggregators:** fill a remote-work feed from public listings.
- **Lead generation teams:** find companies actively hiring.
- **Labor-market researchers:** compare roles by region or industry.
- **Career coaches and job seekers:** build alerts from remote listings.

### Why use this actor?

- **No login:** the actor reads public Jobicy listings.
- **Simple filters:** add tags, category, region, job type, and a result limit.
- **Normalized output:** join, filter, and deduplicate rows without custom parsing.
- **Source URLs included:** every row keeps Jobicy URLs and apply URLs for review or application workflows.

### What data can you extract?

Each dataset row is one remote job listing.
The default view highlights the fields most useful for sourcing and analysis.
Turn on full descriptions only when you need rich job text.

### Output fields

| Field | Description |
| --- | --- |
| `id` | Jobicy job ID |
| `url` | Original Jobicy job URL |
| `jobSlug` | Jobicy slug |
| `title` | Job title |
| `companyName` | Hiring company |
| `companyLogo` | Company logo URL when available |
| `industries` | Jobicy industry labels |
| `jobTypes` | Job type labels such as Full-Time or Contract |
| `geo` | Region or location label |
| `level` | Seniority label when available |
| `excerpt` | Short job summary |
| `description` | Optional full HTML description |
| `publishedAt` | Published date from Jobicy |
| `applyUrl` | Source URL to use for application links |
| `source` | Source marker |
| `scrapedAt` | Timestamp when the actor saved the item |

### Pricing

This actor uses pay-per-event pricing. A `$0.005` `start` event is charged once per run, and an `item` event is charged for each Jobicy job listing saved to the dataset.

Current BRONZE pricing is `$0.000024997` per saved job, about `$0.025` per 1,000 saved jobs, with lower per-job prices on higher Apify tiers.

The prefilled input is intentionally small so the first test run stays inexpensive.
For large recurring monitoring, set `maxItems` to the smallest number that satisfies your workflow.

### How to scrape Jobicy remote jobs

1. Open the actor on Apify.
2. Add one or more keyword tags such as `python`, `react`, or `seo`.
3. Optionally add an industry category slug and region slug.
4. Set the maximum number of jobs to save.
5. Run the actor and download the dataset in your preferred format.

### Input configuration

| Setting | JSON key | Description |
| --- | --- | --- |
| Keywords / tags | `keywords` | Jobicy tag keywords such as `python`, `react`, `seo`, or `sales`. Leave empty for newest remote jobs. |
| Industry category slug | `category` | Optional Jobicy industry slug such as `dev`, `marketing`, `data-science`, `business`, or `supporting`. Legacy `software-engineering` maps to `dev`. |
| Region / geo slug | `geo` | Optional region filter such as `usa`, `europe`, `emea`, `apac`, `latam`, or `worldwide`. |
| Job types | `jobTypes` | Optional client-side job type filters such as `Full-Time`, `Part-Time`, `Contract`, `Freelance`, or `Internship`. |
| Maximum jobs | `maxItems` | Maximum number of job listings saved to the dataset. |
| Include full descriptions | `includeDescription` | Include full HTML job descriptions when available. Turn off for lighter exports. |

### Example input

```json
{
  "keywords": ["python"],
  "category": "dev",
  "geo": "usa",
  "jobTypes": ["Full-Time"],
  "maxItems": 25,
  "includeDescription": false
}
````

### Example output

```json
{
  "id": 147705,
  "url": "https://jobicy.com/jobs/147705-cpq-architect",
  "title": "CPQ Architect",
  "companyName": "Autodesk",
  "industries": ["Software Engineering"],
  "jobTypes": ["Full-Time"],
  "geo": "APAC, Australia",
  "level": "Senior",
  "source": "jobicy"
}
```

### Tips for best results

Start broad, then narrow by industry or region.
Use multiple keyword runs when you want independent monitoring streams.
Keep `includeDescription` off for faster lightweight exports.
Use Apify schedules to refresh results daily or weekly.
Deduplicate downstream by `id` or `url`.

### Integrations

Send new jobs to Google Sheets for recruiter review.
Pipe dataset items into Airtable or Notion for sourcing workflows.
Connect webhooks to Slack alerts when matching jobs appear.
Export JSON to a job board backend or search index.
Use the Apify API from your data warehouse ingestion job.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/jobicy-remote-jobs-scraper').call({
  keywords: ['python'],
  category: 'dev',
  geo: 'usa',
  maxItems: 25,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("fetch_cat/jobicy-remote-jobs-scraper").call(run_input={
    "keywords": ["python"],
    "category": "dev",
    "geo": "usa",
    "maxItems": 25,
})
print(run["defaultDatasetId"])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~jobicy-remote-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["python"],"category":"dev","geo":"usa","maxItems":20}'
```

### MCP and AI agents

Use Apify MCP to run this actor from Claude Code, Claude Desktop, or other MCP-compatible tools.
MCP URL: `https://mcp.apify.com/?tools=fetch_cat/jobicy-remote-jobs-scraper`

Claude Code quick add:

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

Claude Desktop JSON config:

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

Example prompts:

- "Run the Jobicy scraper for Python jobs in the USA and summarize the companies hiring."
- "Find remote marketing jobs and export the dataset URL."
- "Schedule a weekly scrape for full-time data science roles."

### Legality and responsible use

This actor extracts publicly available job listing data.
Respect Jobicy attribution expectations by keeping source links in your product or workflow.
Do not misrepresent job listings, companies, or application links.
Review your own compliance requirements before storing or republishing data.

### Troubleshooting

If you receive fewer results than requested, the selected filters may have limited current listings.
If a category returns broad results, verify that you used a Jobicy industry slug rather than a display label.
If descriptions are large, turn off `includeDescription` for lighter exports.
If scheduled runs repeat rows, deduplicate by `id` in your destination system.

### Related actors

- [Ashby Jobs Scraper](https://apify.com/fetch_cat/ashby-jobs-scraper)
- [ATS Jobs Scraper](https://apify.com/fetch_cat/ats-jobs-scraper)
- [Remote.com Jobs Scraper](https://apify.com/fetch_cat/remote-dot-com-jobs-scraper)
- [RemoteOK Jobs Scraper](https://apify.com/fetch_cat/remoteok-jobs-scraper)
- [Reed.co.uk Jobs Scraper](https://apify.com/fetch_cat/reed-co-uk-jobs-scraper)

### FAQ

#### Can I scrape Jobicy without an account?

Yes. This actor uses public Jobicy listings and does not ask for your Jobicy login.

#### Can I filter by region?

Yes. Use the `geo` input with region slugs such as `usa`, `europe`, `emea`, `apac`, or `latam`.

#### Can I get full job descriptions?

Yes. Enable `includeDescription` to include full HTML descriptions when available.

#### Can I run this every day?

Yes. Use Apify schedules and then send new rows to your preferred destination.

#### What should I use as a unique key?

Use `id` first, with `url` as a secondary unique key.

### Support

If a run fails, returns no data, or a field looks wrong, open an issue from the Actor page.

Please include the Apify run ID or run URL, input JSON, one example public URL, query, or input item, what you expected, and what the dataset returned. Small reproducible inputs make parsing or site-layout issues much faster to fix.

### Changelog

- 2026-07-04 - Feature: Launched Jobicy Remote Jobs Scraper on Apify Store (APIA-1222)
  - This actor is now publicly available at https://apify.com/fetch\_cat/jobicy-remote-jobs-scraper.

#### 0.1

- Initial version for public Jobicy remote job listings with keyword, category, region, job type, and optional description inputs.

### Quick filter examples

#### Python jobs in the USA

keywords=`python`, category=`dev`, geo=`usa`
Use a small `maxItems` value for the first run, then increase it once the filter matches your needs.

#### SEO jobs worldwide

keywords=`seo`, category=`marketing`
Use a small `maxItems` value for the first run, then increase it once the filter matches your needs.

#### Data science in Europe

keywords=`data`, category=`data-science`, geo=`europe`
Use a small `maxItems` value for the first run, then increase it once the filter matches your needs.

#### Customer support in LATAM

category=`supporting`, geo=`latam`
Use a small `maxItems` value for the first run, then increase it once the filter matches your needs.

#### Design roles in APAC

category=`dev`, geo=`apac`
Use a small `maxItems` value for the first run, then increase it once the filter matches your needs.

# Actor input Schema

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

Jobicy tag keywords to search for. Examples: python, react, seo, sales. Leave empty to return the newest remote jobs.

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

Optional Jobicy industry slug such as dev, marketing, data-science, business, or supporting. Legacy software-engineering is accepted and mapped to dev.

## `geo` (type: `string`):

Optional Jobicy region filter such as usa, europe, emea, apac, latam, or worldwide.

## `jobTypes` (type: `array`):

Optional client-side job type filter. Common values include Full-Time, Part-Time, Contract, Freelance, and Internship.

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

Maximum number of job listings to save to the dataset.

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

Include full HTML job descriptions when available. Turn off for lighter exports.

## Actor input object example

```json
{
  "keywords": [
    "python"
  ],
  "category": "dev",
  "geo": "usa",
  "jobTypes": [],
  "maxItems": 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 = {
    "keywords": [
        "python"
    ],
    "category": "dev",
    "geo": "usa",
    "jobTypes": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/jobicy-remote-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": ["python"],
    "category": "dev",
    "geo": "usa",
    "jobTypes": [],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/jobicy-remote-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": [
    "python"
  ],
  "category": "dev",
  "geo": "usa",
  "jobTypes": []
}' |
apify call fetch_cat/jobicy-remote-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobicy Remote Jobs Scraper",
        "description": "Scrape remote job listings from Jobicy by keyword, category, region, and job type.",
        "version": "0.1",
        "x-build-id": "5dYbFJmycay6wERLu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~jobicy-remote-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-jobicy-remote-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~jobicy-remote-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-jobicy-remote-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~jobicy-remote-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-jobicy-remote-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 / tags",
                        "type": "array",
                        "description": "Jobicy tag keywords to search for. Examples: python, react, seo, sales. Leave empty to return the newest remote jobs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Industry category slug",
                        "type": "string",
                        "description": "Optional Jobicy industry slug such as dev, marketing, data-science, business, or supporting. Legacy software-engineering is accepted and mapped to dev."
                    },
                    "geo": {
                        "title": "Region / geo slug",
                        "type": "string",
                        "description": "Optional Jobicy region filter such as usa, europe, emea, apac, latam, or worldwide."
                    },
                    "jobTypes": {
                        "title": "Job types",
                        "type": "array",
                        "description": "Optional client-side job type filter. Common values include Full-Time, Part-Time, Contract, Freelance, and Internship.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of job listings to save to the dataset.",
                        "default": 20
                    },
                    "includeDescription": {
                        "title": "Include full descriptions",
                        "type": "boolean",
                        "description": "Include full HTML job descriptions when available. Turn off for lighter exports.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
