# GCC Jobs Search - Every Board + Recruitment Agencies (`get_anything/gcc-jobs-search`) Actor

Search Gulf jobs in one run, filtered by field, experience, country, city, salary, company and type. An AI-ready tool (ChatGPT / Claude) for job seekers to find UAE, Saudi, Qatar, Kuwait, Bahrain and Oman roles - including recruitment-agency listings - from a single query.

- **URL**: https://apify.com/get\_anything/gcc-jobs-search.md
- **Developed by:** [Get Anything](https://apify.com/get_anything) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## GCC Jobs Search - Every Board + Recruitment Agencies

Find jobs across the Gulf from a single query. Search the UAE, Saudi Arabia, Qatar, Kuwait, Bahrain and Oman at once, then filter by **field, experience level, city, salary, company and job type** - and get one clean, deduplicated list of openings instead of ten browser tabs.

Job seekers in the GCC keep hearing "there are no jobs." Usually there are - they're just scattered across a dozen boards and recruitment-agency sites that never surface in one search. This Actor pulls them together.

### Use it inside ChatGPT or Claude

This Actor is built to be plugged into an AI app as a tool. Connect it through the [Apify MCP server](https://mcp.apify.com) and just ask:

> "Find marketing jobs in Dubai, 5+ years, that offer remote work."
>
> "Show me finance roles in Riyadh posted in the last week."
>
> "Any full-time nursing jobs across the whole Gulf?"

Your assistant maps the request onto the filters below and returns a structured list of live openings with apply links.

### What you get for each job

- Job title and company
- Location, city and country
- Field / function and seniority level (detected from the title)
- Employment type and a remote flag, where the posting states them
- Salary (parsed to a number + currency) when the listing publishes one
- Posted date, normalized across every source
- Which boards it was found on, with a direct apply link to each
- Optional natural **Arabic labels** for titles and companies (using your own Anthropic API key)

### Filters

| Filter | What it does |
|---|---|
| Keywords | One or more role searches |
| Countries | Any mix of UAE, Saudi Arabia, Qatar, Kuwait, Bahrain, Oman |
| City | Keep only jobs in a given city (Dubai, Riyadh, Doha...) |
| Job function | Marketing, Finance, Engineering, Sales, HR and more |
| Experience level | Internship through Executive |
| Employment type | Full-time, part-time, contract, temporary, internship |
| Remote only | Keep only work-from-home roles |
| Company | Keep only a specific employer |
| Minimum salary | Keep only listings that publish a salary at or above your floor |
| Posted within | Keep only recent postings (last N days) |

> **On salary:** most Gulf listings do not publish a salary. The minimum-salary filter only keeps jobs that state one, so use it when you specifically want salary-disclosed roles.

### Sources

| Source | Coverage | Notes |
|---|---|---|
| Bayt.com | All GCC | The region's largest job board |
| GulfTalent | All GCC | Strong for professional and managerial roles |
| NaukriGulf | All GCC | Rich metadata: descriptions, experience ranges |
| Foundit Gulf (ex-Monster) | All GCC | Adds salary + recruitment-agency listings |
| Tanqeeb | All GCC | Aggregator - widens coverage (also surfaces LinkedIn/others) |
| Indeed | All GCC | Optional. Returns salary, but Indeed blocks shared proxies - enable only with your own clean residential proxy |

Everything comes from public search pages and APIs. No login, no cookies, no account risk. Deduplication merges the same role found on multiple sources into one record. New sources (direct recruitment-agency boards) plug in continuously - the same query keeps getting broader.

### Frequently asked questions

**Which country has the most jobs?** The UAE and Saudi Arabia carry the largest volumes; smaller markets (Bahrain, Oman) return fewer but still current listings.

**Can I search several countries at once?** Yes - pick as many as you like under Countries. Each result is tagged with its country.

**Does it remove duplicate postings?** Yes. The same role posted on several boards is merged into one record that lists every source and link. Turn it off to keep raw postings.

**Do I get Arabic job titles?** Optionally. Enable Arabic labels and supply your Anthropic API key, and each title and company gets a natural Arabic label.

**Is scraping these sites allowed?** The Actor only reads public listing pages - the same pages any visitor sees - and does not log in or bypass paywalls.

### Output example

```json
{
  "title": "Senior Accountant",
  "company": "Emirates NBD",
  "location": "Dubai, United Arab Emirates",
  "city": "Dubai",
  "country": "United Arab Emirates",
  "functionGuess": "Finance",
  "seniorityGuess": "Mid-Senior level",
  "employmentType": "full-time",
  "remote": false,
  "salaryText": null,
  "salaryMin": null,
  "salaryCurrency": null,
  "postedDate": "2026-07-21",
  "sources": ["bayt", "naukrigulf"],
  "allLinks": {
    "bayt": "https://www.bayt.com/en/uae/jobs/senior-accountant-...",
    "naukrigulf": "https://www.naukrigulf.com/senior-accountant-..."
  },
  "link": "https://www.bayt.com/en/uae/jobs/senior-accountant-..."
}
````

# Actor input Schema

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

One or more roles or keywords to search, e.g. 'Accountant', 'Digital Marketing Manager', 'Registered Nurse'.

## `countries` (type: `array`):

Which Gulf countries to search. Pick one or several.

## `city` (type: `string`):

Keep only jobs whose location mentions this city, e.g. 'Dubai', 'Riyadh', 'Doha'. Leave empty for the whole country.

## `jobFunction` (type: `string`):

Keep only jobs whose title matches this field. Detected from the job title.

## `experienceLevel` (type: `string`):

Keep only jobs at this seniority. Detected from the job title.

## `employmentType` (type: `string`):

Keep only jobs matching this employment type, where the posting states it.

## `remoteOnly` (type: `boolean`):

Keep only jobs that mention remote / work-from-home.

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

Keep only jobs whose employer name contains this text, e.g. 'Emirates', 'Aramco'.

## `minSalary` (type: `integer`):

Keep only jobs whose stated salary is at least this amount (in the listing's currency). Note: most GCC listings do not publish salary, so this filters out those that don't state one. Leave empty to keep all.

## `datePostedWithinDays` (type: `integer`):

Keep only jobs posted within this many days. Leave empty or 0 for any date.

## `sources` (type: `array`):

Which job sources to search. Foundit adds salary and recruitment-agency listings; Tanqeeb is an aggregator that widens coverage further. Indeed also returns salary but blocks most shared datacenter/residential proxies - enable it only if you supply your own clean residential proxy. Direct recruitment-agency boards are being added next.

## `maxJobsPerSource` (type: `integer`):

Cap on jobs fetched from each board per keyword, per country.

## `deduplicate` (type: `boolean`):

Companies post the same role on several boards. When on, those are merged into one record listing every source it was found on.

## `enableArabicLabels` (type: `boolean`):

Adds natural Arabic labels for job titles and companies via the Anthropic API. Requires anthropicApiKey.

## `anthropicApiKey` (type: `string`):

Only required if enableArabicLabels is true. Never logged or stored in output.

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

Proxy settings for the job-board requests. Apify Proxy is recommended; Bayt needs residential.

## Actor input object example

```json
{
  "keywords": [
    "Accountant"
  ],
  "countries": [
    "uae"
  ],
  "jobFunction": "any",
  "experienceLevel": "any",
  "employmentType": "any",
  "remoteOnly": false,
  "datePostedWithinDays": 0,
  "sources": [
    "bayt",
    "gulftalent",
    "naukrigulf",
    "foundit",
    "tanqeeb"
  ],
  "maxJobsPerSource": 50,
  "deduplicate": true,
  "enableArabicLabels": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Structured results in the default dataset, one item per record.

# 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": [
        "Accountant"
    ],
    "countries": [
        "uae"
    ],
    "sources": [
        "bayt",
        "gulftalent",
        "naukrigulf",
        "foundit",
        "tanqeeb"
    ],
    "maxJobsPerSource": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("get_anything/gcc-jobs-search").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": ["Accountant"],
    "countries": ["uae"],
    "sources": [
        "bayt",
        "gulftalent",
        "naukrigulf",
        "foundit",
        "tanqeeb",
    ],
    "maxJobsPerSource": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("get_anything/gcc-jobs-search").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": [
    "Accountant"
  ],
  "countries": [
    "uae"
  ],
  "sources": [
    "bayt",
    "gulftalent",
    "naukrigulf",
    "foundit",
    "tanqeeb"
  ],
  "maxJobsPerSource": 50
}' |
apify call get_anything/gcc-jobs-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GCC Jobs Search - Every Board + Recruitment Agencies",
        "description": "Search Gulf jobs in one run, filtered by field, experience, country, city, salary, company and type. An AI-ready tool (ChatGPT / Claude) for job seekers to find UAE, Saudi, Qatar, Kuwait, Bahrain and Oman roles - including recruitment-agency listings - from a single query.",
        "version": "0.1",
        "x-build-id": "7dYrGlFjvNTy6Wexo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/get_anything~gcc-jobs-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-get_anything-gcc-jobs-search",
                "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/get_anything~gcc-jobs-search/runs": {
            "post": {
                "operationId": "runs-sync-get_anything-gcc-jobs-search",
                "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/get_anything~gcc-jobs-search/run-sync": {
            "post": {
                "operationId": "run-sync-get_anything-gcc-jobs-search",
                "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",
                "required": [
                    "keywords",
                    "countries"
                ],
                "properties": {
                    "keywords": {
                        "title": "Job title / keywords",
                        "type": "array",
                        "description": "One or more roles or keywords to search, e.g. 'Accountant', 'Digital Marketing Manager', 'Registered Nurse'.",
                        "default": [
                            "Accountant"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Which Gulf countries to search. Pick one or several.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "uae",
                                "saudi-arabia",
                                "qatar",
                                "kuwait",
                                "bahrain",
                                "oman"
                            ],
                            "enumTitles": [
                                "United Arab Emirates",
                                "Saudi Arabia",
                                "Qatar",
                                "Kuwait",
                                "Bahrain",
                                "Oman"
                            ]
                        },
                        "default": [
                            "uae"
                        ]
                    },
                    "city": {
                        "title": "City (optional)",
                        "type": "string",
                        "description": "Keep only jobs whose location mentions this city, e.g. 'Dubai', 'Riyadh', 'Doha'. Leave empty for the whole country."
                    },
                    "jobFunction": {
                        "title": "Job function / field (optional)",
                        "enum": [
                            "any",
                            "Ecommerce",
                            "SEO",
                            "Marketing",
                            "Sales",
                            "Data",
                            "Product",
                            "Engineering",
                            "Design",
                            "Finance",
                            "HR",
                            "Operations",
                            "Customer Service"
                        ],
                        "type": "string",
                        "description": "Keep only jobs whose title matches this field. Detected from the job title.",
                        "default": "any"
                    },
                    "experienceLevel": {
                        "title": "Experience level (optional)",
                        "enum": [
                            "any",
                            "Internship",
                            "Entry level",
                            "Associate",
                            "Mid-Senior level",
                            "Director",
                            "Executive"
                        ],
                        "type": "string",
                        "description": "Keep only jobs at this seniority. Detected from the job title.",
                        "default": "any"
                    },
                    "employmentType": {
                        "title": "Employment type (optional)",
                        "enum": [
                            "any",
                            "full-time",
                            "part-time",
                            "contract",
                            "temporary",
                            "internship"
                        ],
                        "type": "string",
                        "description": "Keep only jobs matching this employment type, where the posting states it.",
                        "default": "any"
                    },
                    "remoteOnly": {
                        "title": "Remote jobs only",
                        "type": "boolean",
                        "description": "Keep only jobs that mention remote / work-from-home.",
                        "default": false
                    },
                    "company": {
                        "title": "Company (optional)",
                        "type": "string",
                        "description": "Keep only jobs whose employer name contains this text, e.g. 'Emirates', 'Aramco'."
                    },
                    "minSalary": {
                        "title": "Minimum monthly salary (optional)",
                        "type": "integer",
                        "description": "Keep only jobs whose stated salary is at least this amount (in the listing's currency). Note: most GCC listings do not publish salary, so this filters out those that don't state one. Leave empty to keep all."
                    },
                    "datePostedWithinDays": {
                        "title": "Posted within (days)",
                        "type": "integer",
                        "description": "Keep only jobs posted within this many days. Leave empty or 0 for any date.",
                        "default": 0
                    },
                    "sources": {
                        "title": "Job sources",
                        "type": "array",
                        "description": "Which job sources to search. Foundit adds salary and recruitment-agency listings; Tanqeeb is an aggregator that widens coverage further. Indeed also returns salary but blocks most shared datacenter/residential proxies - enable it only if you supply your own clean residential proxy. Direct recruitment-agency boards are being added next.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "bayt",
                                "gulftalent",
                                "naukrigulf",
                                "foundit",
                                "tanqeeb",
                                "indeed"
                            ],
                            "enumTitles": [
                                "Bayt.com",
                                "GulfTalent",
                                "NaukriGulf",
                                "Foundit Gulf",
                                "Tanqeeb (aggregator)",
                                "Indeed (needs a clean/own proxy)"
                            ]
                        },
                        "default": [
                            "bayt",
                            "gulftalent",
                            "naukrigulf",
                            "foundit",
                            "tanqeeb"
                        ]
                    },
                    "maxJobsPerSource": {
                        "title": "Max jobs per source",
                        "type": "integer",
                        "description": "Cap on jobs fetched from each board per keyword, per country.",
                        "default": 50
                    },
                    "deduplicate": {
                        "title": "Merge duplicate postings",
                        "type": "boolean",
                        "description": "Companies post the same role on several boards. When on, those are merged into one record listing every source it was found on.",
                        "default": true
                    },
                    "enableArabicLabels": {
                        "title": "Generate Arabic labels",
                        "type": "boolean",
                        "description": "Adds natural Arabic labels for job titles and companies via the Anthropic API. Requires anthropicApiKey.",
                        "default": false
                    },
                    "anthropicApiKey": {
                        "title": "Anthropic API key",
                        "type": "string",
                        "description": "Only required if enableArabicLabels is true. Never logged or stored in output."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings for the job-board requests. Apify Proxy is recommended; Bayt needs residential.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
