# Phone Number Validator (`junipr/phone-number-validator`) Actor Validate and format phone numbers from any country. Check if numbers are valid, identify carrier and line type, determine geographic location, and normalize to E.164 international format. - **URL**: https://apify.com/junipr/phone-number-validator.md - **Developed by:** [junipr](https://apify.com/junipr) (community) - **Categories:** Developer tools, Lead generation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing $1.30 / 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 ## Phone Number Validator ### Introduction Phone Number Validator is a fast, reliable actor for validating, formatting, and enriching phone numbers from any country in the world. Provide a list of phone numbers in any format — E.164, international, national, with dashes, dots, parentheses, vanity letters, or extensions — and get back fully parsed results with validity status, standardized formats, line type classification, timezone, and geographic region. Primary use cases include CRM data hygiene (standardizing phone fields before outreach), SMS campaign preparation (filtering to mobile-only numbers), fraud prevention (detecting VoIP numbers at signup), and lead list enrichment (adding country and line type data to scraped contacts). Processes individual numbers or batches of up to 100,000 in a single run. Key differentiators: no external API dependencies (all validation is offline using Google's libphonenumber), zero configuration required (just provide your phone numbers), and support for messy real-world input formats including vanity numbers (1-800-FLOWERS), numbers with extensions, and Unicode digit characters. ### Why Use This Actor Most phone validation solutions either require expensive external API calls, process one number at a time, or break on real-world messy formatting. This actor solves all three problems. | Feature | This Actor | NumVerify API | Abstract API | Twilio Lookup | Self-hosted libphonenumber | |---------|-----------|---------------|--------------|---------------|----------------------------| | Price per 1,000 checks | $1.30 | $3.00 | $5.00 | $5.00 | Free (self-hosted) | | Batch processing | Yes (100K+) | 1 at a time | 1 at a time | 1 at a time | Code-level | | Line type detection | Yes | Yes | Yes | Yes | Yes | | Timezone detection | Yes | No | No | No | Yes | | Geographic region | Yes | Yes | Yes | Yes | Yes | | E.164 formatting | Yes | Yes | Yes | Yes | Yes | | Vanity number support | Yes | No | No | No | Partial | | Extension extraction | Yes | No | No | No | Partial | | Unicode digit support | Yes | No | No | No | Partial | | Zero-config | Yes | Needs API key | Needs API key | Needs API key | Needs setup | | External API dependency | None | NumVerify | Abstract | Twilio | None | At $1.30 per 1,000 numbers, this actor costs 50–70% less than commercial API alternatives while offering more features. Phone numbers never leave Apify infrastructure — no third-party API sees your contact data. ### How to Use **Zero-config:** Simply provide an array of phone numbers and run. Default settings enable all enrichment (line type, timezone, region) and accept any input format. ```json { "phoneNumbers": ["+14155552671", "(020) 7946 0958", "1-800-FLOWERS"] } ```` **Via Apify API:** ```javascript const { ApifyClient } = require('apify-client'); const client = new ApifyClient({ token: 'YOUR_TOKEN' }); const run = await client.actor('junipr/phone-number-validator').call({ phoneNumbers: ['+14155552671', '+442079460958'], defaultCountryCode: 'US', onlyMobile: false, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); ``` **CRM cleanup workflow:** Export your CRM phone column to a CSV, extract the phone column, feed it to this actor, then use the `e164` output field to update your CRM with standardized E.164 numbers. Use `isValid: false` to flag records that need manual review. **SMS campaign prep:** Set `onlyMobile: true` to filter your list to mobile numbers only. This ensures your SMS campaign only targets numbers that can receive text messages and helps avoid TCPA violations from texting landlines. ### Input Configuration | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `phoneNumbers` | `array` | `["+14155552671", "+442079460958", "+81312345678"]` | Phone numbers to validate. Accepts any format. Max 100,000. | | `defaultCountryCode` | `string` | `"US"` | ISO 3166-1 alpha-2 code applied to numbers without a country prefix (e.g., `"US"`, `"GB"`, `"JP"`). | | `detectCarrier` | `boolean` | `true` | Attempt carrier/operator detection. | | `detectLineType` | `boolean` | `true` | Detect mobile, landline, VoIP, toll-free, etc. | | `includeTimezone` | `boolean` | `true` | Return IANA timezone(s) for the number's country. | | `includeGeocode` | `boolean` | `true` | Return geographic region (country name). | | `strictValidation` | `boolean` | `false` | Reject numbers that don't match the country's exact numbering plan. | | `outputFormat` | `string` | `"all"` | Format output: `"all"` (E.164 + national + international + RFC3966), `"e164"`, or `"national"`. | | `onlyValid` | `boolean` | `false` | Only write valid numbers to the dataset. | | `onlyMobile` | `boolean` | `false` | Only write mobile numbers to the dataset. | | `maxConcurrency` | `integer` | `50` | Concurrent parsing operations (1–100). | **Common configurations:** - **Quick validation** (format + validity only): `detectCarrier: false, includeTimezone: false, includeGeocode: false` - **Full enrichment** (all metadata): use all defaults - **Mobile filter for SMS**: `onlyMobile: true, onlyValid: true` ### Output Format Each phone number produces one dataset item: ```json { "input": "+1 (415) 555-2671", "isValid": true, "isPossible": true, "e164": "+14155552671", "nationalFormat": "(415) 555-2671", "internationalFormat": "+1 415 555 2671", "rfc3966": "tel:+14155552671", "countryCode": "US", "countryCallingCode": "1", "nationalNumber": "4155552671", "extension": null, "lineType": "mobile", "carrier": null, "region": "United States", "timezones": ["America/New_York", "America/Chicago", "America/Denver", "America/Los_Angeles"], "validationErrors": ["CARRIER_UNAVAILABLE"], "checkedAt": "2026-03-11T12:00:00.000Z" } ``` Invalid number example: ```json { "input": "+1415", "isValid": false, "isPossible": false, "e164": null, "nationalFormat": null, "internationalFormat": null, "rfc3966": null, "countryCode": null, "countryCallingCode": null, "nationalNumber": null, "extension": null, "lineType": null, "carrier": null, "region": null, "timezones": [], "validationErrors": ["INVALID_LENGTH"], "checkedAt": "2026-03-11T12:00:00.000Z" } ``` A JSON run summary is saved to the Key-Value Store under the `OUTPUT` key with totals, line type breakdown, and country breakdown. ### Tips and Advanced Usage **Setting `defaultCountryCode`:** If your input list contains national-format numbers without country codes (e.g., `(415) 555-2671` instead of `+14155552671`), set `defaultCountryCode` to the country of origin. Without it, numbers without a `+` prefix will have `COUNTRY_ASSUMED` added to `validationErrors` and will default to US format. **VoIP detection for fraud prevention:** Set `detectLineType: true` (default) and filter results where `lineType === "voip"`. VoIP numbers (Google Voice, Skype, TextNow) are commonly used in signup fraud. Flag these for manual review in your fraud prevention workflow. **SMS campaign targeting:** Use `onlyMobile: true` to pre-filter your dataset. Combined with `isValid: true`, this gives you a clean list of deliverable mobile numbers ready for campaign upload. This also helps with TCPA compliance by ensuring you only text mobile numbers. **Large batch optimization:** For 100K number batches, keep `maxConcurrency` at 50 (default). All processing is in-memory — concurrency primarily affects dataset write throughput, not parsing speed. Memory usage stays well under 256MB regardless of batch size. **Vanity number conversion:** Input numbers like `1-800-FLOWERS` or `1-800-CALL-ATT` are automatically converted to digits before parsing. The output `e164` will contain the digit-only E.164 form. **Extension handling:** Numbers with extensions like `+14155552671 ext. 123` or `+14155552671 x123` have the extension extracted into the `extension` field. The main number is validated without the extension. ### Pricing This actor uses Pay-Per-Event pricing at **$1.30 per 1,000 numbers validated** ($0.0013 per number). Pricing includes all platform compute costs — no hidden fees. | Scenario | Numbers | Estimated Cost | |----------|---------|---------------| | Single validation | 1 | $0.0013 | | CRM cleanup (500 contacts) | 500 | $0.65 | | SMS campaign prep (5,000) | 5,000 | $6.50 | | Lead list enrichment (25,000) | 25,000 | $32.50 | | Enterprise database (100,000) | 100,000 | $130.00 | Empty strings and whitespace-only inputs are not billed. Numbers that produce a result (valid or invalid) count as one billable event. ### FAQ #### Does this check if the number is currently active or connected? No. All validation is done using offline metadata — no calls or pings are made to phone numbers. This is by design: it makes the actor fast, cheap, and compliant with telecom regulations. Validity means the number is structurally correct for the country, not that it is currently in service. Live reachability checks require carrier network access (available via Twilio Lookup or similar services at much higher cost). #### How accurate is carrier detection? Carrier detection is not currently available in the JavaScript port of libphonenumber. The `carrier` field will be `null` for most numbers and a `CARRIER_UNAVAILABLE` warning will appear in `validationErrors`. The Java version of libphonenumber includes carrier prefix databases, but these have not been ported to the JavaScript library. This is a known limitation documented transparently. #### Can I validate numbers without a country code? Yes. Set `defaultCountryCode` to the ISO 3166-1 alpha-2 code of the country your numbers come from (e.g., `"GB"` for UK numbers). Numbers without a `+` prefix will be parsed using that country's numbering plan. A `COUNTRY_ASSUMED` warning is added to `validationErrors` to indicate the assumption was made. #### What is the difference between `isValid` and `isPossible`? `isPossible` is a length-based check — it verifies the number has a plausible number of digits for the country. `isValid` is a stronger check that also validates the number against the country's numbering plan (valid area codes, subscriber number ranges, etc.). A number can be `isPossible: true` but `isValid: false` if it has the right length but uses an invalid area code. With `strictValidation: false` (default), `isValid` is set to true when `isPossible` is true. #### Does it support all countries? Yes. The actor uses `libphonenumber-js/max` which includes full metadata for 200+ countries and territories. This includes complex numbering plans for countries like Argentina, Mexico, Brazil, and India where mobile number formatting has changed over time. #### Can I filter to only mobile numbers for SMS campaigns? Yes. Set `onlyMobile: true` in your input. Only numbers where `lineType === "mobile"` will be written to the dataset. Numbers detected as `FIXED_LINE_OR_MOBILE` are also classified as mobile, since they can receive SMS. This filter is applied before dataset writes but after billing — non-mobile numbers are still counted for billing purposes. #### How does VoIP detection help with fraud prevention? VoIP numbers (Google Voice, Skype, TextNow, Vonage) are not tied to a physical location or carrier contract, making them common in signup fraud, bonus abuse, and fake account creation. When `detectLineType: true`, numbers with `lineType === "voip"` can be flagged for additional verification steps in your signup flow. This doesn't prove fraud, but VoIP at scale is a strong signal worth investigating. #### What formats can I input? The actor accepts virtually any phone number format: E.164 (`+14155552671`), international with spaces (`+1 415 555 2671`), national with parentheses (`(415) 555-2671`), dashes (`415-555-2671`), dots (`415.555.2671`), vanity letters (`1-800-FLOWERS`), numbers with extensions (`+14155552671 ext. 123`), trunk prefixes (`0044...` or `011...`), and Unicode digit characters (Arabic-Indic, Devanagari, etc.). All are normalized before parsing. *** Related actors: [Email Validator & Verifier](https://apify.com/junipr/email-validator) # Actor input Schema ## `phoneNumbers` (type: `array`): List of phone numbers to validate. Accepts any format: E.164 (+14155552671), international (+1 415 555 2671), national ((415) 555-2671), with dashes, dots, parentheses, extensions, or vanity letters (1-800-FLOWERS). Min 1, max 100,000 numbers. ## `defaultCountryCode` (type: `string`): ISO 3166-1 alpha-2 country code applied when phone numbers lack a country prefix. Examples: US, GB, JP, DE, AU. Used for numbers like (415) 555-2671 that have no country code. ## `detectCarrier` (type: `boolean`): Attempt to detect the carrier/operator for the phone number. Note: carrier detection is limited in the underlying library and may return null for most numbers. ## `detectLineType` (type: `boolean`): Detect the line type: mobile, landline, VoIP, toll-free, premium-rate, shared-cost, personal, pager, UAN, or short-code. Essential for SMS campaign targeting (mobile only) and fraud prevention (VoIP detection). ## `includeTimezone` (type: `boolean`): Return timezone(s) associated with the phone number's geographic area based on country. ## `includeGeocode` (type: `boolean`): Return the country/region name associated with the phone number. ## `strictValidation` (type: `boolean`): When enabled, rejects numbers that parse but are not valid for the detected country's numbering plan (wrong digit count, invalid area code, etc.). When disabled, accepts numbers that parse successfully even if not strictly valid. ## `outputFormat` (type: `string`): Which formatted versions to include in output. 'all' includes E.164, national, international, and RFC3966 formats. 'e164' returns E.164 only (+14155552671). 'national' returns national format only ((415) 555-2671). ## `onlyValid` (type: `boolean`): When enabled, only numbers that pass validation are written to the dataset. Invalid numbers are skipped. ## `onlyMobile` (type: `boolean`): When enabled, only numbers detected as mobile line type are written to the dataset. Useful for SMS campaign targeting. ## `maxConcurrency` (type: `integer`): Maximum number of phone numbers to process simultaneously. Higher values process faster but use more memory. ## Actor input object example ```json { "phoneNumbers": [ "+14155552671", "+442079460958", "+81312345678" ], "defaultCountryCode": "US", "detectCarrier": true, "detectLineType": true, "includeTimezone": true, "includeGeocode": true, "strictValidation": false, "outputFormat": "all", "onlyValid": false, "onlyMobile": false, "maxConcurrency": 50 } ``` # Actor output Schema ## `results` (type: `string`): Phone number validation results with E.164 format, line type (mobile/landline/VoIP), country, region, timezones, and validation errors. # 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 = {}; // Run the Actor and wait for it to finish const run = await client.actor("junipr/phone-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 = {} # Run the Actor and wait for it to finish run = client.actor("junipr/phone-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 '{}' | apify call junipr/phone-number-validator --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=junipr/phone-number-validator", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Phone Number Validator", "description": "Validate and format phone numbers from any country. Check if numbers are valid, identify carrier and line type, determine geographic location, and normalize to E.164 international format.", "version": "1.0", "x-build-id": "Djat0Y00Dsg5I2qEO" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/junipr~phone-number-validator/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-junipr-phone-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/junipr~phone-number-validator/runs": { "post": { "operationId": "runs-sync-junipr-phone-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/junipr~phone-number-validator/run-sync": { "post": { "operationId": "run-sync-junipr-phone-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": "List of phone numbers to validate. Accepts any format: E.164 (+14155552671), international (+1 415 555 2671), national ((415) 555-2671), with dashes, dots, parentheses, extensions, or vanity letters (1-800-FLOWERS). Min 1, max 100,000 numbers.", "items": { "type": "string" }, "default": [ "+14155552671", "+442079460958", "+81312345678" ] }, "defaultCountryCode": { "title": "Default Country Code", "type": "string", "description": "ISO 3166-1 alpha-2 country code applied when phone numbers lack a country prefix. Examples: US, GB, JP, DE, AU. Used for numbers like (415) 555-2671 that have no country code.", "default": "US" }, "detectCarrier": { "title": "Detect Carrier", "type": "boolean", "description": "Attempt to detect the carrier/operator for the phone number. Note: carrier detection is limited in the underlying library and may return null for most numbers.", "default": true }, "detectLineType": { "title": "Detect Line Type", "type": "boolean", "description": "Detect the line type: mobile, landline, VoIP, toll-free, premium-rate, shared-cost, personal, pager, UAN, or short-code. Essential for SMS campaign targeting (mobile only) and fraud prevention (VoIP detection).", "default": true }, "includeTimezone": { "title": "Include Timezone", "type": "boolean", "description": "Return timezone(s) associated with the phone number's geographic area based on country.", "default": true }, "includeGeocode": { "title": "Include Geographic Region", "type": "boolean", "description": "Return the country/region name associated with the phone number.", "default": true }, "strictValidation": { "title": "Strict Validation", "type": "boolean", "description": "When enabled, rejects numbers that parse but are not valid for the detected country's numbering plan (wrong digit count, invalid area code, etc.). When disabled, accepts numbers that parse successfully even if not strictly valid.", "default": false }, "outputFormat": { "title": "Output Format", "enum": [ "all", "e164", "national" ], "type": "string", "description": "Which formatted versions to include in output. 'all' includes E.164, national, international, and RFC3966 formats. 'e164' returns E.164 only (+14155552671). 'national' returns national format only ((415) 555-2671).", "default": "all" }, "onlyValid": { "title": "Output Valid Numbers Only", "type": "boolean", "description": "When enabled, only numbers that pass validation are written to the dataset. Invalid numbers are skipped.", "default": false }, "onlyMobile": { "title": "Output Mobile Numbers Only", "type": "boolean", "description": "When enabled, only numbers detected as mobile line type are written to the dataset. Useful for SMS campaign targeting.", "default": false }, "maxConcurrency": { "title": "Max Concurrency", "minimum": 1, "maximum": 100, "type": "integer", "description": "Maximum number of phone numbers to process simultaneously. Higher values process faster but use more memory.", "default": 50 } } }, "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 } } } } } } } } } } ```