# WhatsApp Number Validator - Bulk Phone Check & Cleaner (`memo23/whatsapp-number-validator`) Actor
Bulk WhatsApp number validator & phone checker — 100% offline. Per number: valid/invalid, E.164, country, region, carrier, line type and a WhatsApp-ready flag. Clean contact lists and pre-filter leads. No login, no QR, no ban risk. JSON, CSV or Excel out.
- **URL**: https://apify.com/memo23/whatsapp-number-validator.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Lead generation, Automation, AI
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.50 / 1,000 number validateds
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
## WhatsApp Number Validator
Bulk-validate phone numbers and flag which ones are **WhatsApp-ready** — 100% offline. Feed it a list of numbers and get back, for each one: whether it's a real, well-formed number, its E.164 format, country, region, mobile carrier, line type, and a WhatsApp-ready flag. No login, no QR code, no WhatsApp session, no ban risk.
### Why Use This Scraper?
- **Clean your contact lists before you send.** Drop invalid, malformed, and duplicate numbers so you never waste a message (or a lead) on a dead number.
- **Know which numbers can be on WhatsApp.** Every number gets a `whatsAppReady` flag — valid numbers on a WhatsApp-capable line type (mobile) — so you can pre-filter a list before any outreach.
- **Rich, structured output per number.** Validity, E.164 international format, national format, country, geographic region, mobile carrier, and line type (mobile / landline / VoIP / toll-free) — all in one flat row.
- **100% offline — no login, no ban risk.** It uses Google's `libphonenumber` metadata locally. There is no WhatsApp login, no QR scan, no phone session, and no proxy — so it can't get any number or account banned, and it scales to millions of rows.
- **Built-in filters.** Return only valid numbers, or only WhatsApp-ready numbers, straight from the input — no post-processing needed.
- **Any input, any format.** Paste an array, a spreadsheet column, or a comma-separated blob. International (`+1…`) or local numbers (with a default country) both work.
### Overview
This actor is a **phone-number validation and classification** tool. Give it a batch of phone numbers and it returns one clean, structured record per number describing exactly what that number is.
A note on what "WhatsApp-ready" means, so there are no surprises: the `whatsAppReady` flag is a **capability** signal — it tells you the number is valid and sits on a line type that WhatsApp supports (mobile). It is derived entirely offline and does **not** perform a live query to WhatsApp to confirm the number is actively registered. A genuine live registration check is only possible through an authenticated WhatsApp session (which carries account-ban risk) or a paid third-party provider — neither of which this actor does. What you get instead is fast, unlimited, ban-free filtering that removes the numbers that *cannot* be on WhatsApp (invalid numbers, landlines, fictional ranges) and keeps the ones that can.
Typical uses: cleaning CRM and marketing contact lists, qualifying leads before an outreach campaign, normalizing phone numbers to E.164 for storage, and enriching records with country / region / carrier / line-type metadata.
### Supported Inputs
Mix and match any of these in one run:
- **`phoneNumbers`** — an array of numbers, one per entry. International format (`+15551234567`) is best.
- **`phoneNumbersText`** — paste a whole column: numbers separated by new lines, commas, or semicolons. Merged with `phoneNumbers`. Handy for pasting straight from a spreadsheet.
- **`defaultCountry`** — an ISO country code (e.g. `US`, `GB`, `IN`) applied to any number that has no leading `+` country code, so local-format numbers (`07911 123456`) resolve correctly.
Numbers are de-duplicated automatically before validation.
### Use Cases
| Who | What they use it for |
| --- | --- |
| **Sales & outreach teams** | Pre-filter a lead list to only WhatsApp-ready mobiles before a campaign, so no sends are wasted on landlines or dead numbers. |
| **Marketers & agencies** | Clean and normalize bulk contact lists to E.164, dedupe, and drop invalid numbers before importing into a sending platform. |
| **CRM / RevOps** | Enrich contact records with country, region, carrier, and line type; standardize phone formats across a database. |
| **Developers** | A no-infrastructure phone-validation endpoint — POST a batch, get structured results back via the Apify API. |
| **Data / list brokers** | Quality-score and segment large phone datasets by validity, line type, and country. |
### How It Works
1. **Input** — give the actor a list of numbers (array, pasted column, or CSV blob), optionally with a `defaultCountry` for local-format numbers.
2. **Validate offline** — each number is parsed against Google's `libphonenumber` metadata (bundled, no network): validity, E.164 + national format, country, region, carrier, and line type are derived, and the WhatsApp-ready flag is computed from the line type.
3. **Emit** — each number becomes one flat row, streamed to the dataset for download as JSON, CSV, or Excel, or via the API. Optional filters return only valid or only WhatsApp-ready numbers.
### Input Configuration
| Field | Type | Description |
| --- | --- | --- |
| `phoneNumbers` | array | Phone numbers to validate, one per entry. International format preferred. |
| `phoneNumbersText` | string | Alternative — paste numbers separated by new lines, commas, or semicolons. Merged with `phoneNumbers`. |
| `defaultCountry` | string | ISO 2-letter country code (e.g. `US`, `GB`, `IN`) for numbers without a leading `+` country code. |
| `includeGeoCarrier` | boolean | Attach geographic region and mobile carrier when derivable offline. Default `true`. |
| `onlyValid` | boolean | Output only valid, well-formed numbers — drop invalid/garbage input. Default `false`. |
| `onlyWhatsAppReady` | boolean | Output only numbers that are valid AND on a WhatsApp-capable line type. Default `false`. |
| `maxItems` | integer | Hard cap on how many numbers to process this run. |
#### Example input
```json
{
"phoneNumbers": ["+14155238886", "+919876543210", "+442071838750", "not-a-number"],
"phoneNumbersText": "+33 6 12 34 56 78\n+49 151 12345678",
"defaultCountry": "US",
"includeGeoCarrier": true,
"onlyWhatsAppReady": false
}
````
### Output Overview
Every number is emitted as one flat JSON object with a consistent schema — fields a given number can't resolve (e.g. carrier for a landline) come back `null` rather than missing, so the shape stays stable across the whole dataset. Download as JSON, CSV, Excel, or pull via the Apify API.
### Output Samples
A valid mobile (WhatsApp-ready):
```jsonc
{
"input": "+919876543210",
"valid": true,
"possible": true,
"e164": "+919876543210",
"international": "+91 98765 43210",
"national": "098765 43210",
"countryCode": "IN",
"countryCallingCode": "+91",
"lineType": "MOBILE",
"region": null,
"carrier": "Airtel",
"whatsAppReady": true,
"error": null,
"validatedAt": "2026-07-08T04:12:07.000Z"
}
```
A valid landline (not WhatsApp-ready):
```jsonc
{
"input": "+44 20 7183 8750",
"valid": true,
"e164": "+442071838750",
"countryCode": "GB",
"lineType": "FIXED_LINE",
"region": "London",
"carrier": null,
"whatsAppReady": false,
"error": null
}
```
An invalid number:
```jsonc
{
"input": "not-a-number",
"valid": false,
"possible": false,
"e164": null,
"countryCode": null,
"lineType": null,
"whatsAppReady": false,
"error": "empty or too short"
}
```
### Key Output Fields
**Validity**
- `valid` — a real, assigned number for its country
- `possible` — well-formed for its country even if not an assigned range
- `error` — why an invalid number failed (`null` when valid)
**Formats**
- `e164` — canonical international format (`+15551234567`) for storage
- `international`, `national` — human-readable formats
**Geography & network**
- `countryCode` — ISO country (e.g. `US`, `IN`)
- `countryCallingCode` — dialing code (e.g. `+91`)
- `region` — geographic area (e.g. `California`, `London`), when known
- `carrier` — mobile network operator (e.g. `Airtel`), when derivable offline
**Classification**
- `lineType` — `MOBILE`, `FIXED_LINE`, `FIXED_LINE_OR_MOBILE`, `VOIP`, `TOLL_FREE`, etc.
- `whatsAppReady` — valid **and** on a WhatsApp-capable line type (mobile)
- `validatedAt` — ISO timestamp of validation
### FAQ
**Does this confirm a number is actually registered on WhatsApp?**
No — and no honest tool can do that without either a logged-in WhatsApp session (which risks getting the account banned) or a paid third-party provider. This actor does the next best thing, entirely offline: it tells you whether a number is valid and *capable* of being on WhatsApp (a real mobile number), which removes every number that definitely can't be — invalid numbers, landlines, and fictional ranges — so your list is clean before you ever send.
**Do I need a WhatsApp account, login, or QR scan?**
No. There is no login, no QR code, no phone session, and no proxy. Everything runs offline against bundled phone-number metadata, so no number or account is ever put at ban risk.
**What formats can I paste?**
International (`+15551234567`) works everywhere. For local-format numbers without a `+` country code (e.g. `07911 123456`), set `defaultCountry` and they'll resolve correctly. You can paste an array or a whole spreadsheet column (new-line / comma / semicolon separated).
**How is `whatsAppReady` computed?**
A number is `whatsAppReady` when it is valid AND its line type is WhatsApp-capable — `MOBILE`, or `FIXED_LINE_OR_MOBILE` for countries (like the US and Canada) whose numbering plan doesn't distinguish the two. Landlines, toll-free, and invalid numbers come back `false`.
**Where do region and carrier come from?**
From Google's `libphonenumber` geocoding and carrier metadata, resolved offline. Coverage varies by country — mobile carrier is strongest for countries with carrier-specific number ranges (e.g. India), and region is strongest for countries with geographic area codes. Turn it off with `includeGeoCarrier: false` if you don't need it.
**How fast is it, and how many numbers can it handle?**
Very fast — it's pure CPU with no network calls. It comfortably validates hundreds of numbers in seconds and scales to very large lists. Use `maxItems` to cap a run.
**What export formats are supported?**
Every run writes to an Apify dataset you can download as JSON, CSV, Excel, XML, or JSONL, or fetch via the Apify API — and wire into scheduling, webhooks, Google Sheets, Zapier, or Make.
### Support
- **Found a bug or need a new field?** Open a ticket on the **Issues** tab of this actor — it's the fastest way to reach me and I actively maintain this actor.
- **Email:**
- **Website:** [muhamed-didovic.github.io](https://muhamed-didovic.github.io/)
### Additional Services
Need something beyond the standard output? I build and maintain custom actors and data pipelines. Happy to help with:
- Live WhatsApp registration checks wired to your own provider API key
- Custom fields, filters, or export formats tailored to your workflow
- Enrichment beyond phone metadata (email discovery, firmographics, social profiles)
- Private or dedicated actors for high-volume or compliance-sensitive use
Reach out via the Issues tab or email and describe what you need.
### Explore More Scrapers
Browse my other Apify actors — job boards, business directories, review sites, social platforms, and more — on my profile: [memo23 on Apify](https://apify.com/memo23).
### ⚠️ Disclaimer
WhatsApp is a trademark of WhatsApp LLC and Meta Platforms, Inc. This actor is an independent tool and is **not** affiliated with, authorized by, endorsed by, or in any way officially connected to WhatsApp, WhatsApp LLC, or Meta Platforms.
This actor performs **offline phone-number validation** using publicly available numbering-plan metadata. It does not connect to WhatsApp, does not access any WhatsApp account or private data, and does not confirm live registration status.
You are responsible for how you use the data you process. Use it in compliance with applicable laws (including the GDPR, TCPA, CAN-SPAM, and other data-protection and anti-spam regulations) and any consent and contractual obligations you may have. In particular, validating a number does not constitute consent to contact it — ensure your outreach complies with the relevant marketing and messaging laws in your jurisdiction. Do not use this tool to facilitate spam, harassment, or any violation of privacy.
### SEO Keywords
whatsapp number validator, whatsapp number checker, phone number validator, bulk phone validation, phone number verification, e164 formatter, libphonenumber api, whatsapp lead filter, contact list cleaner, phone number cleaner, mobile number validator, carrier lookup, line type detection, phone number normalization, crm data cleaning, lead qualification, whatsapp marketing tool, bulk number check, phone validation api, no-code phone validator
# Actor input Schema
## `phoneNumbers` (type: `array`):
Phone numbers to validate, one per entry. International format (+15551234567) is best. Local numbers (e.g. 07911123456) work if you also set a Default country below.
## `phoneNumbersText` (type: `string`):
Alternative to the list above — paste numbers separated by new lines, commas, or semicolons. Merged with the list. Handy for pasting a spreadsheet column.
## `defaultCountry` (type: `string`):
ISO 2-letter country code (e.g. US, GB, IN) applied to numbers that have NO leading +country code. Leave empty if all your numbers are in international format.
## `includeGeoCarrier` (type: `boolean`):
Attach the geographic region (e.g. California, London) and mobile carrier (e.g. Airtel) when derivable offline. Adds no network calls.
## `onlyValid` (type: `boolean`):
Drop invalid / malformed numbers from the output — return only well-formed, assigned numbers.
## `onlyWhatsAppReady` (type: `boolean`):
Return only numbers that are valid AND on a WhatsApp-capable line type (mobile). Use this to pre-filter a list before any live WhatsApp outreach.
## `maxItems` (type: `integer`):
Hard cap on how many numbers to process this run.
## Actor input object example
```json
{
"phoneNumbers": [
"+14155238886",
"+919876543210",
"+442071838750",
"+1 (202) 555-0123"
],
"includeGeoCarrier": true,
"onlyValid": false,
"onlyWhatsAppReady": false,
"maxItems": 100000
}
```
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"phoneNumbers": [
"+14155238886",
"+919876543210",
"+442071838750",
"+1 (202) 555-0123"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("memo23/whatsapp-number-validator").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = { "phoneNumbers": [
"+14155238886",
"+919876543210",
"+442071838750",
"+1 (202) 555-0123",
] }
# Run the Actor and wait for it to finish
run = client.actor("memo23/whatsapp-number-validator").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 '{
"phoneNumbers": [
"+14155238886",
"+919876543210",
"+442071838750",
"+1 (202) 555-0123"
]
}' |
apify call memo23/whatsapp-number-validator --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=memo23/whatsapp-number-validator",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "WhatsApp Number Validator - Bulk Phone Check & Cleaner",
"description": "Bulk WhatsApp number validator & phone checker — 100% offline. Per number: valid/invalid, E.164, country, region, carrier, line type and a WhatsApp-ready flag. Clean contact lists and pre-filter leads. No login, no QR, no ban risk. JSON, CSV or Excel out.",
"version": "0.0",
"x-build-id": "mS6Nrwiwnvelmxcxt"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/memo23~whatsapp-number-validator/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-memo23-whatsapp-number-validator",
"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/memo23~whatsapp-number-validator/runs": {
"post": {
"operationId": "runs-sync-memo23-whatsapp-number-validator",
"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/memo23~whatsapp-number-validator/run-sync": {
"post": {
"operationId": "run-sync-memo23-whatsapp-number-validator",
"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": {
"phoneNumbers": {
"title": "Phone numbers",
"type": "array",
"description": "Phone numbers to validate, one per entry. International format (+15551234567) is best. Local numbers (e.g. 07911123456) work if you also set a Default country below.",
"items": {
"type": "string"
}
},
"phoneNumbersText": {
"title": "Phone numbers (paste a list)",
"type": "string",
"description": "Alternative to the list above — paste numbers separated by new lines, commas, or semicolons. Merged with the list. Handy for pasting a spreadsheet column."
},
"defaultCountry": {
"title": "Default country",
"type": "string",
"description": "ISO 2-letter country code (e.g. US, GB, IN) applied to numbers that have NO leading +country code. Leave empty if all your numbers are in international format."
},
"includeGeoCarrier": {
"title": "Include region & carrier",
"type": "boolean",
"description": "Attach the geographic region (e.g. California, London) and mobile carrier (e.g. Airtel) when derivable offline. Adds no network calls.",
"default": true
},
"onlyValid": {
"title": "Only output valid numbers",
"type": "boolean",
"description": "Drop invalid / malformed numbers from the output — return only well-formed, assigned numbers.",
"default": false
},
"onlyWhatsAppReady": {
"title": "Only output WhatsApp-ready numbers",
"type": "boolean",
"description": "Return only numbers that are valid AND on a WhatsApp-capable line type (mobile). Use this to pre-filter a list before any live WhatsApp outreach.",
"default": false
},
"maxItems": {
"title": "Max numbers",
"minimum": 1,
"type": "integer",
"description": "Hard cap on how many numbers to process this run.",
"default": 100000
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```