# Social & Crypto Phone Number Checker - 25 Platforms (`clearpath/social-crypto-phone-number-checker`) Actor

Check phone numbers in bulk for account registration on 25 platforms: Instagram, Facebook, Snapchat, Signal, Binance, KuCoin, and more. Get registered, unregistered, or unknown per number. Export to CSV, JSON, or Excel. Up to 100,000 numbers per run, no proxy or login required.

- **URL**: https://apify.com/clearpath/social-crypto-phone-number-checker.md
- **Developed by:** [ClearPath](https://apify.com/clearpath) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 number checked (standard)s

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Social & Crypto Phone Number Checker

Check phone numbers in bulk for **account registration across 25 platforms**, one selectable platform per run.

Pick a platform (Instagram, Facebook, Snapchat, Signal, Binance, KuCoin, and more), provide your numbers, and each one comes back as `registered`, `unregistered`, or `unknown`. Numbers are checked **one country at a time** and mixed-country lists are split automatically. Up to **100,000 numbers per run**; oversized inputs are deduped and trimmed to the first 100,000.

Use it to **find which contacts use a platform**, **clean and segment lists before outreach**, **validate leads**, and keep CRM phone data fresh.

<table><tr>
<td style="border-left:4px solid rgb(76,148,94);padding:12px 16px;font-weight:600">One actor, 25 platforms. Select a platform, upload up to 100,000 phone numbers, and get a registered / unregistered / unknown result for each in a single file.</td>
</tr></table>

&nbsp;

<table>
<tr>
<td colspan="5" style="padding:10px 14px;background:#006D77;border:none;border-radius:4px 4px 0 0">
<span style="color:#FAFAF9;font-size:14px;font-weight:700;letter-spacing:0.5px">Clearpath Phone Intelligence</span>
<span style="color:#EDF6F9;font-size:13px">&nbsp;&nbsp;&bull;&nbsp;&nbsp;Bulk validation and profile enrichment for messaging platforms</span>
</td>
</tr>
<tr>
<td style="padding:12px 16px;border:1px solid #E7E5E4;border-radius:0 0 0 4px;border-right:none;border-top:none;vertical-align:top;width:20%">
<img src="https://apify-image-uploads-prod.s3.us-east-1.amazonaws.com/DSvMCAwsufMyZeLyt-actor-5VRd0yDjFG6Ocsoga-FL7gTGa0Qu-whatsapp-message-export-api-logo.png" width="24" height="24" style="vertical-align:middle"> &nbsp;<a href="https://apify.com/clearpath/whatsapp-phone-number-validator-api" style="color:#1C1917;text-decoration:none;font-weight:700;font-size:14px">WhatsApp Number Validator</a><br>
<span style="color:#78716C;font-size:12px">Bulk WhatsApp yes/no checks</span>
</td>
<td style="padding:12px 16px;border:1px solid #E7E5E4;border-right:none;border-top:none;vertical-align:top;width:20%">
<img src="https://apify-image-uploads-prod.s3.us-east-1.amazonaws.com/DSvMCAwsufMyZeLyt-actor-z8ABjm5J4jtfnoP3f-jig5XaWPPa-telegram-phone-number-validator-logo.png" width="24" height="24" style="vertical-align:middle"> &nbsp;<a href="https://apify.com/clearpath/telegram-phone-number-validator" style="color:#1C1917;text-decoration:none;font-weight:700;font-size:14px">Telegram Number Validator</a><br>
<span style="color:#78716C;font-size:12px">Bulk Telegram account checks</span>
</td>
<td style="padding:12px 16px;border:1px solid #E7E5E4;border-right:none;border-top:none;vertical-align:top;width:20%">
<img src="https://apify-image-uploads-prod.s3.us-east-1.amazonaws.com/DSvMCAwsufMyZeLyt-actor-spae6psFHel5wvUw2-GlofGipqSp-whatsapp-icon-logo-svgrepo-com.svg.png" width="24" height="24" style="vertical-align:middle"> &nbsp;<a href="https://apify.com/clearpath/whatsapp-profile-avatar-age-gender-api" style="color:#1C1917;text-decoration:none;font-weight:700;font-size:14px">WhatsApp Profile Avatar API</a><br>
<span style="color:#78716C;font-size:12px">Avatar, age &amp; gender enrichment</span>
</td>
<td style="padding:12px 16px;border:1px solid #E7E5E4;border-right:none;border-top:none;vertical-align:top;width:20%">
<a href="https://apify.com/clearpath/phone-number-active-checker" style="color:#1C1917;text-decoration:none;font-weight:700;font-size:14px">Phone Active Status Checker</a><br>
<span style="color:#78716C;font-size:12px">Carrier-level active checks</span>
</td>
<td style="padding:12px 16px;border:1px solid #E7E5E4;border-radius:0 0 4px 0;border-top:none;vertical-align:top;width:20%">
<a href="https://apify.com/clearpath/max-messenger-number-checker" style="color:#1C1917;text-decoration:none;font-weight:700;font-size:14px">MAX Messenger Number Checker</a><br>
<span style="color:#78716C;font-size:12px">Bulk MAX account checks</span>
</td>
</tr>
</table>

#### Copy to your AI assistant

````

clearpath/social-crypto-phone-number-checker on Apify. Bulk account-registration checks across 25 platforms (Instagram, Facebook, Snapchat, Signal, Binance, KuCoin, and more); returns registered, unregistered, or unknown per number. Call ApifyClient("TOKEN").actor("clearpath/social-crypto-phone-number-checker").call(run\_input={...}), then client.dataset(run\["defaultDatasetId"]).list\_items().items. Real runs need testMode=false, a platform value, and enough numbers to meet that platform's minimum (100-5,000) via phoneNumbers or csvFile. Full spec: GET https://api.apify.com/v2/acts/clearpath~social-crypto-phone-number-checker/builds/default (Bearer TOKEN) → inputSchema, actorDefinition.storages.dataset, readme. Token: https://console.apify.com/account/integrations

````

### Supported Platforms

| Platform | Platform | Platform | Platform | Platform |
|---|---|---|---|---|
| Instagram | Facebook | Messenger | Threads | X (Twitter) |
| Snapchat | Viber | Signal | Line | iMessage |
| RCS | Zalo | Band | GoTo | Apple ID |
| Microsoft | Amazon | Netflix | Indiatimes | HT |
| Cian | Binance | KuCoin | CoinW | Htx |

WhatsApp, Telegram, and MAX have dedicated actors in the suite (linked above).

### Quick Start

Preview sample output without charges:

```json
{
  "platform": "instagram",
  "testMode": true,
  "phoneNumbers": ["+14155552671"]
}
````

Check a direct list:

```json
{
  "platform": "binance",
  "testMode": false,
  "phoneNumbers": [
    "+14155552671",
    "+442071234567"
  ],
  "onlyRegisteredNumbers": false
}
```

Upload CSV/XLSX and apply a default country code:

```json
{
  "platform": "snapchat",
  "testMode": false,
  "csvFile": "uploaded-file.csv",
  "defaultCountryCode": "1",
  "onlyRegisteredNumbers": true
}
```

### Input

For real runs, select a `platform` and provide at least one of `phoneNumbers` or `csvFile`.

The actor is fully hosted on Apify. You provide phone numbers or an uploaded file; no extra credentials are required.

| Parameter | Type | Description |
|-----------|------|-------------|
| `platform` | string | Which platform to check (Instagram, Facebook, Binance, etc.). |
| `testMode` | boolean | Returns sample output without checking real numbers or charging credits. |
| `phoneNumbers` | array | Phone numbers with country code. Grouped by country; each country needs the platform minimum (100 to 5,000). Smaller country groups come back as `unchecked`. Processes the first 100,000 after dedupe. |
| `csvFile` | string | Uploaded CSV or Excel file with phone numbers. |
| `defaultCountryCode` | string | Country code to prepend to numbers without a `+` prefix. Recommended for national-format lists. |
| `onlyRegisteredNumbers` | boolean | Output only numbers where `status` is `registered`. |

#### How countries are handled

Each platform checks **one country per submission** and enforces a per-country minimum. The actor handles this for you:

- Numbers are validated, grouped by country, and each country is checked separately, then merged into one result set.
- A country with **fewer than the platform minimum** (100 to 5,000 depending on platform) is returned as `status: unchecked` with `skipReason: below_country_minimum`.
- Numbers that can't be validated are returned as `status: unchecked` with `skipReason: invalid_format`.
- If a platform is temporarily unavailable for a country, those rows return `skipReason: platform_unavailable`.

For national-format lists (no `+`), set `defaultCountryCode` so numbers validate and group correctly.

#### CSV/Excel File Requirements

- **Supported formats**: `.csv`, `.xlsx`
- **Delimiters**: Comma, semicolon, tab, pipe (auto-detected)
- **Column detection**: Automatically finds phone columns including:
  - Standard: `phone`, `mobile`, `cell`, `tel`, `telephone`, `whatsapp`
  - Variations: `phone number`, `mobile number`, `cell phone`, `contact number`
  - CRM exports: `mobile phone`, `direct phone`, `work phone`, `personal phone`, `primary phone`
  - International: `telefon`, `telefono`, `téléphone`, `celular`, `handy`
- **No headers?** Scans content to find phone-like columns automatically

### Output

One dataset item per input number. Checked numbers carry a `status`; numbers that
could not be checked are returned as `unchecked` with a `skipReason` (and are not billed).

```json
[
  {
    "phoneNumber": "+919049117257",
    "platform": "snapchat",
    "originalInput": "9049117257",
    "countryCode": "IN",
    "isValidFormat": true,
    "status": "registered",
    "isRegistered": true,
    "skipReason": null,
    "checkedAt": "2026-06-10T08:00:00Z"
  },
  {
    "phoneNumber": "+919876543210",
    "platform": "snapchat",
    "originalInput": "+91 98765 43210",
    "countryCode": "IN",
    "isValidFormat": true,
    "status": "unregistered",
    "isRegistered": false,
    "skipReason": null,
    "checkedAt": "2026-06-10T08:00:00Z"
  },
  {
    "phoneNumber": "+919812345678",
    "platform": "snapchat",
    "originalInput": "+919812345678",
    "countryCode": "IN",
    "isValidFormat": true,
    "status": "unknown",
    "isRegistered": null,
    "skipReason": null,
    "checkedAt": "2026-06-10T08:00:00Z"
  },
  {
    "phoneNumber": "+12025550123",
    "platform": "snapchat",
    "originalInput": "+1 202 555 0123",
    "countryCode": "US",
    "isValidFormat": true,
    "status": "unchecked",
    "isRegistered": null,
    "skipReason": "below_country_minimum",
    "checkedAt": "2026-06-10T08:00:00Z"
  },
  {
    "phoneNumber": null,
    "platform": "snapchat",
    "originalInput": "not-a-number",
    "countryCode": null,
    "isValidFormat": false,
    "status": "unchecked",
    "isRegistered": null,
    "skipReason": "invalid_format",
    "checkedAt": "2026-06-10T08:00:00Z"
  }
]
```

### Output Fields

| Field | Description |
|-------|-------------|
| `phoneNumber` | Normalized E.164 phone number (`null` for numbers that could not be validated). |
| `platform` | Platform the number was checked against. |
| `originalInput` | Original value supplied by the user. |
| `countryCode` | Detected country (ISO 3166 alpha-2, e.g. `US`, `IN`). |
| `isValidFormat` | Whether the number is a valid phone number. |
| `status` | `registered`, `unregistered`, `unknown`, or `unchecked`. |
| `isRegistered` | `true` when registered, `false` when unregistered, `null` when unknown or unchecked. |
| `skipReason` | Why a number was not checked: `below_country_minimum`, `invalid_format`, or `platform_unavailable`. `null` for checked numbers. |
| `checkedAt` | ISO timestamp of the check. |

### Pricing

The actor uses pay-per-event pricing with one event per checked number. The rate depends on the selected platform, because platforms vary widely in cost. You only see the rate for the platform you run.

Rates per 1,000 checked numbers (no subscription / Gold and above):

| Tier | Platforms | Per 1,000 (base / Gold) |
|------|-----------|------------------------:|
| Standard | Instagram, Facebook, Messenger, Threads, X, Viber, iMessage, RCS, Zalo, Band, Apple ID, Microsoft, Amazon, Indiatimes, HT, Cian, CoinW | $4.99 / $2.99 |
| Plus | Signal, Htx | $5.99 / $3.59 |
| Pro | Binance | $9.99 / $5.99 |
| Premium | GoTo, Line, Netflix, KuCoin | $10.99 / $6.59 |
| Ultra | Snapchat | $22.99 / $13.79 |

Silver and Bronze subscribers fall between the base and Gold rates. Duplicates are removed before checking, so you pay for unique numbers checked. You are only billed for numbers actually checked; `unchecked` rows are free.

### Notes

- `unknown` means the registration status could not be determined for that number; it still counts as a checked number.
- `unchecked` numbers (below a country's minimum, invalid, or a temporarily unavailable platform) are returned with a `skipReason` and are never billed.
- Uploaded CSV/XLSX files can use common phone columns such as `phone`, `mobile`, or `telephone`.
- `onlyRegisteredNumbers` filters output rows, but billing still applies to every checked number.

***

### FAQ

**Q: Can I check more than one platform in a single run?**
A: No. Each run checks one platform. Run the actor again with a different `platform` to check another.

**Q: How accurate are the results?**
A: Statuses reflect account registration on the selected platform at the time of the check.

**Q: What countries are supported?**
A: Worldwide. Numbers must include a country code, or set `defaultCountryCode` for national-format lists. Each country is checked separately; a country needs the platform minimum to be checked.

**Q: Can I mix countries in one list?**
A: Yes. The actor groups your numbers by country and checks each separately, then merges the results. Countries below the platform minimum come back as `unchecked`.

**Q: How fast is it?**
A: Most batches complete within a few minutes. Larger batches scale accordingly.

**Q: What about duplicates?**
A: Auto-removed after normalization. You are only charged for unique numbers.

**Q: What does `unknown` mean?**
A: The registration status could not be determined for that number. It still counts as a checked number.

**Q: Is there a minimum batch size?**
A: Yes, and it is **per country** (100 to 5,000 depending on platform). Each country in your list needs at least that many numbers to be checked; smaller country groups come back as `unchecked`. The maximum is 100,000 per run.

***

### 📧 Support

- **Email**: max@mapa.slmail.me
- **Feature Requests**: Email or submit via issues
- **Response Time**: Typically within 24 hours

***

### Legal

This actor checks phone number registration on third-party platforms. Users are responsible for complying with applicable data protection regulations (GDPR, CCPA) when processing phone number lists.

# Actor input Schema

## `platform` (type: `string`):

Which platform to check phone numbers against. Each platform reports whether a number has a registered account.

## `testMode` (type: `boolean`):

Return sample records without checking real numbers or charging credits.<br><br><b>Disable this for real runs.</b>

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

Add phone numbers with country code, for example <code>+14155552671</code>.<br><br>Numbers are grouped by country and each country is checked separately. A country needs at least the platform's minimum (100 to 5,000) to be checked; smaller country groups are returned as <code>unchecked</code>. Oversized inputs are trimmed to the first 100,000 unique numbers.

## `csvFile` (type: `string`):

Upload a CSV or Excel <code>.xlsx</code> file containing phone numbers.<br><br>The actor detects common phone columns such as <code>phone</code>, <code>mobile</code>, <code>telephone</code>, and <code>whatsapp</code>.<br><br><b>Tip:</b> Use the upload button above for best results. Files you upload here, and files in your own Apify storage, are read automatically. For a link to a private Key-Value Store in another account, make the store public or re-upload the file here.

## `defaultCountryCode` (type: `string`):

Country code to prepend when a number does not start with <code>+</code>. Recommended for national-format lists so numbers validate and group to the right country.<br><br>Examples: <code>1</code> for US/Canada, <code>44</code> for UK, <code>91</code> for India.

## `onlyRegisteredNumbers` (type: `boolean`):

Output only numbers where <code>status</code> is <code>registered</code>.<br><br>Billing still applies to every checked number.

## Actor input object example

```json
{
  "platform": "instagram",
  "testMode": true,
  "phoneNumbers": [
    "+14155552671"
  ],
  "onlyRegisteredNumbers": false
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "platform": "instagram",
    "testMode": true,
    "phoneNumbers": [
        "+14155552671"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("clearpath/social-crypto-phone-number-checker").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 = {
    "platform": "instagram",
    "testMode": True,
    "phoneNumbers": ["+14155552671"],
}

# Run the Actor and wait for it to finish
run = client.actor("clearpath/social-crypto-phone-number-checker").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 '{
  "platform": "instagram",
  "testMode": true,
  "phoneNumbers": [
    "+14155552671"
  ]
}' |
apify call clearpath/social-crypto-phone-number-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Social & Crypto Phone Number Checker - 25 Platforms",
        "description": "Check phone numbers in bulk for account registration on 25 platforms: Instagram, Facebook, Snapchat, Signal, Binance, KuCoin, and more. Get registered, unregistered, or unknown per number. Export to CSV, JSON, or Excel. Up to 100,000 numbers per run, no proxy or login required.",
        "version": "0.0",
        "x-build-id": "8t6nwk9uX8YwbEzqZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/clearpath~social-crypto-phone-number-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-clearpath-social-crypto-phone-number-checker",
                "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/clearpath~social-crypto-phone-number-checker/runs": {
            "post": {
                "operationId": "runs-sync-clearpath-social-crypto-phone-number-checker",
                "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/clearpath~social-crypto-phone-number-checker/run-sync": {
            "post": {
                "operationId": "run-sync-clearpath-social-crypto-phone-number-checker",
                "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": {
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "instagram",
                            "facebook",
                            "messenger",
                            "threads",
                            "twitter",
                            "snapchat",
                            "viber",
                            "signal",
                            "line",
                            "imessage",
                            "rcs",
                            "zalo",
                            "band",
                            "goto",
                            "apple",
                            "microsoft",
                            "amazon",
                            "netflix",
                            "indiatimes",
                            "ht",
                            "cian",
                            "binance",
                            "kucoin",
                            "coinw",
                            "htx"
                        ],
                        "type": "string",
                        "description": "Which platform to check phone numbers against. Each platform reports whether a number has a registered account.",
                        "default": "instagram"
                    },
                    "testMode": {
                        "title": "Test Mode",
                        "type": "boolean",
                        "description": "Return sample records without checking real numbers or charging credits.<br><br><b>Disable this for real runs.</b>",
                        "default": false
                    },
                    "phoneNumbers": {
                        "title": "Phone Numbers",
                        "minItems": 1,
                        "maxItems": 100000,
                        "type": "array",
                        "description": "Add phone numbers with country code, for example <code>+14155552671</code>.<br><br>Numbers are grouped by country and each country is checked separately. A country needs at least the platform's minimum (100 to 5,000) to be checked; smaller country groups are returned as <code>unchecked</code>. Oversized inputs are trimmed to the first 100,000 unique numbers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "csvFile": {
                        "title": "CSV/Excel File",
                        "type": "string",
                        "description": "Upload a CSV or Excel <code>.xlsx</code> file containing phone numbers.<br><br>The actor detects common phone columns such as <code>phone</code>, <code>mobile</code>, <code>telephone</code>, and <code>whatsapp</code>.<br><br><b>Tip:</b> Use the upload button above for best results. Files you upload here, and files in your own Apify storage, are read automatically. For a link to a private Key-Value Store in another account, make the store public or re-upload the file here."
                    },
                    "defaultCountryCode": {
                        "title": "Default Country Code",
                        "type": "string",
                        "description": "Country code to prepend when a number does not start with <code>+</code>. Recommended for national-format lists so numbers validate and group to the right country.<br><br>Examples: <code>1</code> for US/Canada, <code>44</code> for UK, <code>91</code> for India."
                    },
                    "onlyRegisteredNumbers": {
                        "title": "Only Registered Numbers",
                        "type": "boolean",
                        "description": "Output only numbers where <code>status</code> is <code>registered</code>.<br><br>Billing still applies to every checked number.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
