# Phone Number Lookup API (`khadinakbar/phone-number-lookup-api`) Actor

All-in-one phone intelligence API. Validates any number, returns carrier, line type (mobile/landline/VoIP), country, region, owner name (US/CA), fraud score, breach data, WhatsApp/Telegram presence, and reverse-lookup URLs in a single call. 240+ countries.

- **URL**: https://apify.com/khadinakbar/phone-number-lookup-api.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, Developer tools, MCP servers
- **Stats:** 14 total users, 12 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Lookup API — Carrier, Owner Name, Fraud Score, WhatsApp & Telegram Check

**Validate, enrich, and reverse-lookup any phone number worldwide.** This actor returns 40+ data fields per number including carrier, line type (mobile/landline/VoIP), country, region, city, owner name (US/CA), fraud score, breach data, WhatsApp/Telegram registration status, and pre-built reverse-lookup search URLs — all in a single API call. Powered by Google's libphonenumber + IPQualityScore + free OSINT enrichment. Works with **240+ countries**.

Built for sales teams cleaning lead lists, fraud teams scoring inbound calls, RevOps automating CRM hygiene, and AI agents needing structured phone metadata via MCP.

### What does Phone Number Lookup API do?

It takes any phone number — international (`+12025551234`) or local (`(202) 555-1234` with a country code) — and returns everything publicly knowable about it in one structured JSON response:

- **Validation & format**: E.164, international, national, and RFC 3966 formats
- **Geography**: country, region, city, ZIP code, timezone
- **Telecom**: carrier (real-time HLR), line type (mobile/landline/VoIP/toll-free/premium), MCC/MNC codes, ported flag, original carrier
- **Fraud signals**: 0-100 fraud score, recent abuse, leaked-in-breach flag, spammer flag, DNC registry status, SMS deliverability score
- **Identity**: owner name (US/CA via CNAM), associated emails (where available)
- **Cross-platform presence**: WhatsApp registration + business flag, Telegram registration + public name/photo
- **Reverse-lookup URLs**: pre-formatted search URLs for Google, Whitepages, Truecaller, BeenVerified, Spokeo, 800notes, MrNumber, Facebook, LinkedIn

Process **1 number or up to 10,000 per run**. Per-number error isolation means one bad input never kills your whole batch.

### Why use Phone Number Lookup API?

Most phone validators on Apify just wrap Google's libphonenumber library — they tell you if a number is syntactically valid and not much more. This actor goes far beyond:

- **Real fraud detection** — 0-100 fraud score, leaked-in-breach lookup, spammer database, DNC registry status
- **Owner identification** — name where available (US/CA via CNAM), associated emails
- **Real-time HLR carrier** — actual current carrier (portability-aware), not the static carrier-at-issuance most actors return
- **Cross-platform presence** — WhatsApp + Telegram registration check baked in (no separate actor needed)
- **Reverse-lookup URLs** — instant manual investigation links for Google, Whitepages, Truecaller, etc.
- **Bulk-friendly** — up to 10,000 per run, configurable concurrency, hard cost ceiling, streaming output, resume on failure
- **MCP-native** — perfect tool for Claude/GPT/Cursor agents (1 input, structured JSON out, predictable cost)
- **No setup** — bring nothing. We handle all the API keys.

#### Use cases

- **Sales / RevOps**: clean lead lists before SMS or dialer campaigns; filter out invalid, VoIP, and toll-free numbers
- **Trust & Safety**: score inbound numbers, detect spam/scam/fraud signals, check DNC registry
- **CRM hygiene**: bulk-enrich phone records with carrier, region, line type, and owner name
- **Compliance / KYC**: verify number ownership, line type, and active status before onboarding
- **Real estate / skip-tracing**: enrich seller/lead phones with owner details and cross-platform footprint
- **AI agents**: 1 MCP call returns the full phone profile — no chaining 4 actors

### How to use Phone Number Lookup API

1. Click **Try for free** above to open the actor in Apify Console.
2. In the Input tab, paste your phone numbers (one per line) — international format `+12025551234` works best. For local-format numbers, also set **Default country** (e.g. `US`).
3. Optionally tweak: **Concurrency** (default 20), **Max cost cap**, toggle **WhatsApp/Telegram checks**.
4. Click **Start**.
5. Watch the live progress: `Processed 240/5000 (4.8%) · 198 valid · 12 spam-flagged · $6.00 spent`.
6. When done, open the **Output** tab → preview, or download as **JSON / CSV / Excel / HTML**.

For programmatic use, hit our API endpoint directly:

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~phone-number-lookup-api/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "phoneNumbers": ["+12025551234", "+447911123456"],
    "defaultCountry": "US"
  }'
````

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `phoneNumbers` | string\[] | — (required) | Up to 10,000 numbers. E.164 preferred. |
| `defaultCountry` | string | `US` | ISO 3166-1 alpha-2 fallback for local-format numbers. |
| `maxConcurrency` | integer | `20` | Parallel lookups (1-100). |
| `includeReverseLookupUrls` | boolean | `true` | Generate Google/Whitepages/Truecaller search URLs. |
| `includeWhatsAppCheck` | boolean | `true` | Test WhatsApp registration. |
| `includeTelegramCheck` | boolean | `true` | Test Telegram registration + fetch public name/photo. |
| `enableUnofficialSources` | boolean | `false` | Reserved for v2 (Truecaller/GetContact). |
| `maxCostUsd` | integer | unset | Hard spending cap per run. |

### Output

Each number returns one record with this shape (simplified):

```json
{
  "inputNumber": "+12025551234",
  "valid": true,
  "e164": "+12025551234",
  "international": "+1 202-555-1234",
  "national": "(202) 555-1234",
  "rfc3966": "tel:+1-202-555-1234",
  "countryCode": "US",
  "countryCallingCode": "+1",
  "countryName": "United States",
  "region": "DC",
  "city": "Washington",
  "zipCode": "20001",
  "timezones": ["America/New_York"],
  "lineType": "mobile",
  "isMobile": true,
  "isLandline": false,
  "isVoip": false,
  "carrier": "Verizon Wireless",
  "originalCarrier": "T-Mobile USA",
  "ported": true,
  "mobileCountryCode": "310",
  "mobileNetworkCode": "012",
  "active": true,
  "fraudScore": 12,
  "risky": false,
  "recentAbuse": false,
  "leakedInBreach": false,
  "spammer": false,
  "dncStatus": "not_on_dnc_registry",
  "smsScore": 95,
  "name": "John Doe",
  "associatedEmails": ["j.doe@example.com"],
  "whatsApp": { "registered": true, "isBusiness": false },
  "telegram": { "registered": true, "publicName": "John D" },
  "reverseLookupUrls": {
    "google": "https://www.google.com/search?q=%2B12025551234",
    "truecaller": "https://www.truecaller.com/search/intl/12025551234",
    "whitepages": "https://www.whitepages.com/phone/12025551234"
  },
  "sources": ["libphonenumber", "ipqualityscore", "whatsapp", "telegram", "reverse_lookup_urls"],
  "warnings": [],
  "lookedUpAt": "2026-05-03T19:42:00.123Z"
}
```

You can download the dataset in **JSON, CSV, Excel, JSONL, RSS, or HTML table** format.

### Data fields returned

| Category | Fields |
|---|---|
| **Validation** | valid, formatted, e164, international, national, rfc3966 |
| **Geography** | countryCode, countryCallingCode, countryName, region, city, zipCode, timezones |
| **Telecom** | lineType, isMobile, isLandline, isVoip, isTollFree, isPremiumRate, carrier, originalCarrier, ported, mobileCountryCode, mobileNetworkCode, active |
| **Fraud / Risk** | fraudScore, risky, recentAbuse, leakedInBreach, spammer, dncStatus, smsScore |
| **Identity** | name, associatedEmails |
| **Presence** | whatsApp.registered, whatsApp.isBusiness, telegram.registered, telegram.publicName, telegram.publicPhotoUrl |
| **Reverse lookup** | URLs for Google, Whitepages, Truecaller, BeenVerified, Spokeo, 800notes, MrNumber, Facebook, LinkedIn |
| **Metadata** | sources\[], warnings\[], lookedUpAt |

### Pricing — How much does it cost to look up phone numbers?

Pay-per-event pricing. You pay only for what you use — no monthly minimums, no setup fees.

| Event | Price | When charged |
|---|---|---|
| Actor start | $0.00005 | Per RAM-GB, charged once per run |
| **Phone looked up** | **$0.025** | Per number successfully processed |

#### Cost examples

- **1 number** (one-off lookup): ~$0.025
- **100 numbers** (small lead batch): ~$2.50
- **1,000 numbers** (medium CRM cleanup): ~$25
- **10,000 numbers** (large enrichment job): ~$250

#### Cost cap

Set `maxCostUsd` in input to hard-cap your spend. The actor stops gracefully when reached — no surprise bills.

### Tips & advanced options

- **Always pass E.164 format** (`+12025551234`) when possible — local formats need a default country and may misparse.
- **For huge batches (>10,000)**, split into multiple runs and use Apify Tasks to chain them.
- **For real-time fraud screening**, use the API endpoint with single numbers and webhook callbacks for sub-2-second response.
- **Lower concurrency** to 5-10 if you see IPQS rate-limit warnings — IPQS allows generous limits but bursts of 50+ may throttle.
- **Disable WhatsApp/Telegram checks** if you only need validation + fraud — saves 200-500ms per number.
- **Pipe output into your other Apify actors** — pair with `b2b-lead-finder-enrichment`, `linkedin-profile-email-scraper`, `bulk-website-contact-extractor`, or `google-maps-leads-scraper` for end-to-end lead enrichment.

### FAQ

**Which countries are supported?**
All 240+ countries recognized by ITU-T E.164 (literally every country on Earth). Owner-name data is strongest for US, Canada, UK, EU, India, and Australia.

**How accurate is the carrier data?**
Real-time HLR via IPQualityScore — portability-aware (tells you the *current* carrier, not the carrier at number issuance). Falls back to libphonenumber's static carrier data if IPQS lookup fails.

**Does this work for landlines?**
Yes — landlines, mobile, VoIP, toll-free, premium-rate, personal numbers, pagers, and shared-cost lines are all supported and classified.

**Does it return profile pictures like Truecaller?**
For WhatsApp business accounts, yes. For Telegram public profiles, yes. For general "Truecaller-style" name lookup beyond US/CA, that requires unofficial sources which are reserved for v2 (opt-in flag with TOS disclaimer).

**Can I use this in real-time during a phone call?**
Yes — call the synchronous API endpoint with a single number; typical response time is 1-3 seconds.

**Is bulk processing reliable?**
Yes. Per-number error isolation means one bad input doesn't kill your batch. The actor streams results to the dataset as each number completes, so you can start downloading partial results before the full run finishes.

**Can I limit my spend?**
Yes — set `maxCostUsd` in input. The actor stops gracefully when the cap is reached.

### Legal & disclaimers

This actor uses publicly available data sources — Google's open-source libphonenumber library, IPQualityScore's commercial fraud database, and public WhatsApp/Telegram presence indicators (no message content, no profile data scraping).

**You are responsible for the legal use of this data in your jurisdiction.** This includes but is not limited to:

- Compliance with GDPR, CCPA, TCPA, and other applicable privacy/telecom laws
- Honoring DNC registry restrictions (the actor flags DNC status — you must respect it)
- Not using the data for harassment, stalking, fraud, or unauthorized commercial outreach
- Consent and disclosure obligations when enriching personal data

The actor is provided "as is" without warranty. Carrier and ownership data is sourced from third-party providers and may be incomplete or outdated. Do not rely solely on this data for life-or-safety decisions.

### Support

Found a bug, have a feature request, or want to chat about your use case? Open an **Issue** on this actor's page.

### Related actors in this portfolio

Pair Phone Number Lookup API with these to build full lead enrichment pipelines:

- [B2B Lead Finder + Enrichment](https://apify.com/khadinakbar/b2b-lead-finder-enrichment) — find leads via Google Maps + emails, then enrich phones here
- [LinkedIn Profile + Email Scraper](https://apify.com/khadinakbar/linkedin-profile-email-scraper) — get LinkedIn profiles with phones, then validate
- [Bulk Website Contact Extractor](https://apify.com/khadinakbar/bulk-website-contact-extractor) — extract contacts from any URL list, then enrich phones
- [Universal Lead Finder](https://apify.com/khadinakbar/universal-lead-finder) — niche+city leads with phones for enrichment
- [Google Maps Leads Scraper](https://apify.com/khadinakbar/google-maps-leads-scraper) — local business phones to enrich and DNC-screen

# Actor input Schema

## `phoneNumbers` (type: `array`):

Array of phone numbers to enrich (max 10,000 per run). Use E.164 format (e.g., '+12025551234') for best accuracy. Local formats like '(202) 555-1234' work if you also set defaultCountry. Each number is charged separately. NOT a search query — this is exact-match lookup only.

## `defaultCountry` (type: `string`):

Two-letter country code (e.g., 'US', 'GB', 'IN', 'DE') used as fallback when a phone number has no country code prefix. Only needed for local-format numbers like '(555) 123-4567'. Leave empty if all numbers are already in E.164 format.

## `maxConcurrency` (type: `integer`):

Number of phone numbers processed in parallel. Higher = faster but may hit IPQS rate limits. Default 20 is safe for most cases. Max 100. Lower this to 5-10 if you see rate-limit warnings.

## `includeReverseLookupUrls` (type: `boolean`):

Adds pre-built search URLs for Google, Whitepages, Truecaller, BeenVerified, Spokeo, 800notes, MrNumber, Facebook, and LinkedIn so you can investigate any number manually with one click. Free, no extra cost. Defaults to true.

## `includeWhatsAppCheck` (type: `boolean`):

Tests whether the number is in a format WhatsApp would accept (uses unauthenticated wa.me redirect). EXPERIMENTAL — without WhatsApp Business API auth (planned for v2), this only confirms format validity, not actual registration status. Set true if you want the field populated. Defaults to false.

## `includeTelegramCheck` (type: `boolean`):

Tests whether the number has a public Telegram profile (uses t.me redirect). Returns public name + photo if profile exists, otherwise registered: false. Note: most Telegram users have private profiles and will return false even if registered. Defaults to true.

## `enableUnofficialSources` (type: `boolean`):

Reserved for v2 — will enable Truecaller and GetContact unofficial APIs for global owner-name lookup. Currently a no-op flag (logs a notice). Use of unofficial sources may violate third-party Terms of Service in some jurisdictions; user is responsible for legal compliance.

## `maxCostUsd` (type: `integer`):

Hard spending cap per run (in USD). Actor stops gracefully when reached. Useful for bulk runs where you want to limit exposure. Leave at 0 for no cap. Example: 50 means actor stops after spending $50.

## Actor input object example

```json
{
  "phoneNumbers": [
    "+12025551234",
    "+447911123456",
    "+919876543210",
    "+33612345678",
    "+5511987654321"
  ],
  "defaultCountry": "US",
  "maxConcurrency": 20,
  "includeReverseLookupUrls": true,
  "includeWhatsAppCheck": false,
  "includeTelegramCheck": true,
  "enableUnofficialSources": false,
  "maxCostUsd": 0
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset with enriched data: validation, format, country, region, city, carrier, line type, fraud score, owner name, WhatsApp/Telegram presence, reverse-lookup URLs.

## `datasetCsv` (type: `string`):

Same data as the dataset, formatted as CSV for spreadsheet import.

## `datasetExcel` (type: `string`):

Same data as the dataset, formatted as XLSX for Excel.

## `input` (type: `string`):

The original input passed to this run (phone numbers, options).

## `consoleRun` (type: `string`):

Live status, logs, and dataset preview.

# 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 = {
    "phoneNumbers": [
        "+12025551234",
        "+447911123456",
        "+919876543210",
        "+33612345678",
        "+5511987654321"
    ],
    "defaultCountry": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/phone-number-lookup-api").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 = {
    "phoneNumbers": [
        "+12025551234",
        "+447911123456",
        "+919876543210",
        "+33612345678",
        "+5511987654321",
    ],
    "defaultCountry": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/phone-number-lookup-api").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": [
    "+12025551234",
    "+447911123456",
    "+919876543210",
    "+33612345678",
    "+5511987654321"
  ],
  "defaultCountry": "US"
}' |
apify call khadinakbar/phone-number-lookup-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=khadinakbar/phone-number-lookup-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Phone Number Lookup API",
        "description": "All-in-one phone intelligence API. Validates any number, returns carrier, line type (mobile/landline/VoIP), country, region, owner name (US/CA), fraud score, breach data, WhatsApp/Telegram presence, and reverse-lookup URLs in a single call. 240+ countries.",
        "version": "1.4",
        "x-build-id": "lulIwDhgnGJ0z7ksP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~phone-number-lookup-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-phone-number-lookup-api",
                "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/khadinakbar~phone-number-lookup-api/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-phone-number-lookup-api",
                "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/khadinakbar~phone-number-lookup-api/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-phone-number-lookup-api",
                "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": [
                    "phoneNumbers"
                ],
                "properties": {
                    "phoneNumbers": {
                        "title": "Phone numbers to look up",
                        "minItems": 1,
                        "maxItems": 10000,
                        "type": "array",
                        "description": "Array of phone numbers to enrich (max 10,000 per run). Use E.164 format (e.g., '+12025551234') for best accuracy. Local formats like '(202) 555-1234' work if you also set defaultCountry. Each number is charged separately. NOT a search query — this is exact-match lookup only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "defaultCountry": {
                        "title": "Default country (ISO 3166-1 alpha-2)",
                        "type": "string",
                        "description": "Two-letter country code (e.g., 'US', 'GB', 'IN', 'DE') used as fallback when a phone number has no country code prefix. Only needed for local-format numbers like '(555) 123-4567'. Leave empty if all numbers are already in E.164 format.",
                        "default": "US"
                    },
                    "maxConcurrency": {
                        "title": "Concurrent lookups",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of phone numbers processed in parallel. Higher = faster but may hit IPQS rate limits. Default 20 is safe for most cases. Max 100. Lower this to 5-10 if you see rate-limit warnings.",
                        "default": 20
                    },
                    "includeReverseLookupUrls": {
                        "title": "Generate reverse-lookup URLs",
                        "type": "boolean",
                        "description": "Adds pre-built search URLs for Google, Whitepages, Truecaller, BeenVerified, Spokeo, 800notes, MrNumber, Facebook, and LinkedIn so you can investigate any number manually with one click. Free, no extra cost. Defaults to true.",
                        "default": true
                    },
                    "includeWhatsAppCheck": {
                        "title": "Check WhatsApp format validity (experimental)",
                        "type": "boolean",
                        "description": "Tests whether the number is in a format WhatsApp would accept (uses unauthenticated wa.me redirect). EXPERIMENTAL — without WhatsApp Business API auth (planned for v2), this only confirms format validity, not actual registration status. Set true if you want the field populated. Defaults to false.",
                        "default": false
                    },
                    "includeTelegramCheck": {
                        "title": "Check Telegram public profile",
                        "type": "boolean",
                        "description": "Tests whether the number has a public Telegram profile (uses t.me redirect). Returns public name + photo if profile exists, otherwise registered: false. Note: most Telegram users have private profiles and will return false even if registered. Defaults to true.",
                        "default": true
                    },
                    "enableUnofficialSources": {
                        "title": "Enable unofficial sources (v2 — coming soon)",
                        "type": "boolean",
                        "description": "Reserved for v2 — will enable Truecaller and GetContact unofficial APIs for global owner-name lookup. Currently a no-op flag (logs a notice). Use of unofficial sources may violate third-party Terms of Service in some jurisdictions; user is responsible for legal compliance.",
                        "default": false
                    },
                    "maxCostUsd": {
                        "title": "Max cost ceiling (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard spending cap per run (in USD). Actor stops gracefully when reached. Useful for bulk runs where you want to limit exposure. Leave at 0 for no cap. Example: 50 means actor stops after spending $50.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
