# Instagram Account Checker Active or Inactive. No login. (`karamelo/instagram-account-checker-active-or-inactive`) Actor

Check whether Instagram accounts are active or inactive fast and reliable.

- **URL**: https://apify.com/karamelo/instagram-account-checker-active-or-inactive.md
- **Developed by:** [karamelo](https://apify.com/karamelo) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 results

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Overview

Instagram Account Checker is a high-speed verification Actor designed to check whether Instagram profiles are active or inactive. Whether you manage influencer marketing campaigns, maintain contact databases, conduct brand protection audits, or audit lead lists, verifying account validity before outreach saves time, protects domain reputation, and eliminates wasted budget on non-existent or deactivated profiles.

The Actor accepts bulk lists of Instagram usernames, `@handles`, or profile URLs. It verifies each account and produces structured, schema-compliant records indicating whether each account is `active` (accessible and valid on Instagram) or `inactive` (non-existent, deleted, or suspended). All verification happens securely without requiring your personal Instagram credentials, login tokens, or session cookies.

***

### What does Instagram Account Checker do?

Validating account existence on social platforms is a critical initial step for digital marketers, sales operations, and data teams. Instagram Account Checker automates this verification across dozens, hundreds, or thousands of accounts simultaneously.

Specifically, the Actor:

- **Verifies account status**: Determines with high accuracy whether each submitted account is currently live and active or inactive.
- **Normalizes diverse input formats**: Automatically sanitizes and extracts clean usernames from raw strings, handle notations with `@`, and direct profile URLs including those with tracking parameters or trailing slashes.
- **Provides instant classification**: Outputs standardized status tags (`active` or `inactive`) for each target account.
- **Delivers clean dataset results**: Exports flat, tabular data ready for immediate integration into spreadsheets, CRM platforms, outreach sequences, or automated pipelines.
- **Operates non-invasively**: Checks account existence through public availability without interacting with the account holder, generating notifications, or leaving visible footprints.

***

### Who is Instagram Account Checker for?

#### 1. Influencer Marketing Agencies & Talent Managers

Before pitching sponsors or executing influencer contracts, agencies must ensure that creator handles are active and accessible. Checking lists of candidate influencers prevents embarrassing outreach to abandoned or deactivated handles.

#### 2. Lead Generation & Sales Development Teams

Sales teams enriching CRM databases with social media profiles frequently encounter stale data. Scrubbing contact records through this Actor ensures your sales development representatives only target active social profiles.

#### 3. Brand Protection & Intellectual Property Specialists

Brand protection teams monitoring copyright infringements, counterfeiters, or trademark impersonators can verify whether reported infringing accounts remain active or have been taken down by the platform.

#### 4. Database Administrators & Marketing Operations

Marketing ops professionals maintaining email lists, user databases, and community registries need automated tools to prune invalid and deleted handles, ensuring clean analytics and accurate user profiles.

#### 5. Academic Researchers & OSINT Analysts

Researchers conducting social media studies or open-source intelligence investigations can quickly confirm the operational state of large batches of subject accounts without manual browser verification.

***

### Why use Instagram Account Checker?

- **Batch Verification Capability** — Process single accounts or large batches of usernames in a single execution.
- **Credential-Free Operation** — No Instagram account, login credentials, or personal access tokens required.
- **Flexible Input Formatting** — Accepts handles with or without `@`, direct profile URLs, and web links.
- **Deterministic Status Output** — Clear binary categorization into `active` and `inactive` statuses without ambiguous intermediate states.
- **Zero Account Footprint** — Verification does not send notifications, follow requests, or alert account owners.
- **Production-Ready Exports** — Export findings directly in JSON, CSV, Microsoft Excel, XML, or HTML formats.
- **API & Webhook Support** — Trigger checks automatically via Apify REST API, Python client, JavaScript/Node.js client, or Zapier integrations.

***

### Key features and capabilities

| Feature | Description | Benefit |
|---|---|---|
| **Bulk Processing** | Accepts arrays of hundreds or thousands of target usernames | Eliminate manual, time-consuming individual profile lookups |
| **Input Normalization** | Extracts clean usernames from URLs, `@handles`, and messy text | No need to pre-clean your data before running the Actor |
| **Definitive Status** | Categorizes profiles into `active` or `inactive` | Unambiguous results for downstream automation and filtering |
| **Non-Intrusive** | Public status checking with zero target interaction | Protect your privacy and avoid notifying profile owners |
| **Dataset Table View** | Pre-configured `Overview` table in the Apify Console | Inspect results immediately in your browser without exporting |
| **Multi-Format Export** | Direct download in CSV, JSON, XLSX, XML, and RSS | Ready for import into Google Sheets, Airtable, or CRM tools |

***

### Use cases

#### Influencer Campaign Roster Validation

Marketing managers assembling influencer outreach lists often compile handles from historical spreadsheets, discovery tools, and event registrations. Running the roster through Instagram Account Checker flags deleted or renamed accounts before marketing dollars and outreach efforts are spent.

#### CRM & Contact Database Hygiene

Over time, customer databases and CRM contacts degrade. Customers change usernames, delete old personal accounts, or create new ones. Scheduling periodic verification runs allows marketing operations to archive stale records and maintain high contact quality.

#### Brand Enforcement & Takedown Verification

When legal and brand protection teams issue takedown requests for trademark violations or impersonation accounts, they need to monitor whether those accounts have been removed. This Actor allows automated confirmation of account suspension or removal.

#### Social Media Sweepstakes & Contest Auditing

Brands running social media contests often receive thousands of participant entries. Checking participant handles verifies that contest entrants hold valid, active accounts before picking and announcing winners.

#### Market & Competitive Research

Analysts benchmarking market segments or monitoring industry creator networks can track account persistence over time, identifying attrition rates and platform departures across specific creator cohorts.

***

### Getting started

Running your first check with Instagram Account Checker takes less than a minute.

#### Step 1: Open the Actor

Navigate to the Actor page in the Apify Store and click the **Try for free** or **Run** button to open the input console.

#### Step 2: Provide Target Usernames

Enter the usernames you want to verify in the **Usernames** field. You can input plain usernames, handles with `@`, or full profile URLs. For multiple accounts, add each username on a separate line or comma-separated string list.

```json
{
  "usernames": [
    "instagram",
    "cristiano",
    "@nasa",
    "https://www.instagram.com/natgeo/"
  ]
}
```

#### Step 3: Run the Actor

Click the green **Start** button at the bottom of the page. The Actor will begin processing each username in your list, updating the status message with real-time progress.

#### Step 4: Review and Export Results

Once the run finishes, navigate to the **Output** or **Storage** tab. You can inspect the table of results directly or download your dataset in CSV, Excel, or JSON format.

***

### Input reference

The Actor is designed for maximum simplicity, requiring only the list of target usernames.

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `usernames` | Array of Strings | Yes | `["instagram", "definitely_not_active_404"]` | A list of Instagram usernames, `@handles`, or profile URLs to verify. |

#### Supported Input Formats

The input parser automatically handles the following common formats:

1. **Standard username**: `instagram` or `cristiano`
2. **Handle with leading symbol**: `@instagram` or `@cristiano`
3. **Canonical profile URL**: `https://www.instagram.com/instagram/`
4. **Short profile URL**: `http://instagram.com/cristiano`
5. **URL with query tracking**: `https://www.instagram.com/nasa?igsh=MXR3OG...`
6. **URL with hash fragment**: `https://www.instagram.com/natgeo/#main`

Leading whitespace, trailing slashes, and uppercase letters are automatically normalized and converted to lowercase.

***

### Output data structure

The Actor stores its results in the default Apify Dataset. Each output item represents one verified account with exactly two standardized properties:

| Field | Type | Description | Values |
|---|---|---|---|
| `username` | String | The normalized Instagram username that was verified. | e.g., `"instagram"`, `"definitely_not_active_404"` |
| `status` | String | The verification outcome indicating account availability. | `"active"` or `"inactive"` |

#### Status Definitions

- **`active`**: The profile is live, registered, and accessible on Instagram. The user profile exists and can be reached.
- **`inactive`**: The profile is not accessible. This indicates that the username does not exist, has been deleted, is suspended, or has been disabled.

#### Sample Output Record: Active Account

```json
{
  "username": "instagram",
  "status": "active"
}
```

#### Sample Output Record: Inactive Account

```json
{
  "username": "definitely_not_active_404",
  "status": "inactive"
}
```

***

### Operational tips for best results

#### Batch Sizing

- For routine ad-hoc verification, batches of 10 to 500 usernames complete quickly and allow immediate review.
- For bulk database cleaning involving thousands of usernames, submit the accounts in batches of 1,000 to 5,000 per run. This keeps dataset downloads manageable and makes tracking progress easy.

#### Input Hygiene

- While the Actor automatically strips `@` symbols and URL wrappers, ensure that usernames do not contain extraneous punctuation like commas or quotes within the handle string itself.
- Valid Instagram usernames consist of letters (`a-z`), numbers (`0-9`), periods (`.`), and underscores (`_`), with a maximum length of 30 characters.

#### Incremental Verification

- When monitoring a recurring list of contacts, consider saving previous results. On subsequent runs, you only need to verify accounts whose status was previously questionable or accounts that have not been checked recently.

***

### Automation workflows and integration recipes

#### Workflow 1: Pre-Campaign Influencer Outreach Validation

Before launching an outreach sprint in your marketing software:

1. Export candidate influencer usernames from your discovery spreadsheet.
2. Trigger the Actor via the Apify API or console with the candidate list.
3. Download the CSV dataset.
4. Filter for `status == "inactive"` to immediately eliminate inactive handles from your CRM sequence.
5. Proceed with outreach confident that all target handles are reachable.

#### Workflow 2: Automated CRM Contact Hygiene

Keep customer contact databases up to date:

1. Set up a scheduled monthly run on the Apify platform using your CRM's Instagram handle list.
2. Configure an Apify Webhook to fire upon run completion.
3. Send the webhook payload to Make.com or Zapier.
4. Update the contact record in HubSpot, Salesforce, or Airtable, flagging inactive accounts for customer service follow-up.

#### Workflow 3: Brand Impersonation & Enforcement Tracking

When defending your brand against impersonator handles:

1. Maintain an inventory of identified infringing profile URLs.
2. Schedule a weekly Apify run to test each handle.
3. When an account shifts from `active` to `inactive`, automatically alert your legal team that the account takedown has taken effect.

***

### Apify API and programmatic usage

You can integrate Instagram Account Checker into your existing software stack using the official Apify API clients.

#### Python Integration

```python
from apify_client import ApifyClient

  # Initialize the ApifyClient with your API token
client = ApifyClient("YOUR_APIFY_TOKEN")

  # Prepare Actor input
run_input = {
    "usernames": [
        "instagram",
        "cristiano",
        "definitely_not_active_404"
    ]
}

  # Run the Actor and wait for completion
run = client.actor("karamelo/instagram-account-checker-active-or-inactive").call(run_input=run_input)

  # Fetch results from the default dataset
dataset_items = client.dataset(run["defaultDatasetId"]).list_items().items

for item in dataset_items:
    print(f"User: @{item['username']} -> Status: {item['status']}")
```

#### JavaScript / Node.js Integration

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

// Initialize the ApifyClient with your API token
const client = new ApifyClient({
    token: 'YOUR_APIFY_TOKEN',
});

// Prepare Actor input
const input = {
    usernames: [
        'instagram',
        'cristiano',
        'definitely_not_active_404',
    ],
};

// Run the Actor and wait for completion
const run = await client.actor('karamelo/instagram-account-checker-active-or-inactive').call(input);

// Fetch results from the default dataset
const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const item of items) {
    console.log(`User: @${item.username} -> Status: ${item.status}`);
}
```

#### Apify CLI Command

You can also run the Actor directly from your terminal using the Apify CLI:

```bash
echo '{"usernames": ["instagram", "definitely_not_active_404"]}' | apify call karamelo/instagram-account-checker-active-or-inactive --output-dataset
```

***

### Data export and platform integrations

The results collected by Instagram Account Checker can be consumed in multiple ways:

#### Standard File Exports

- **CSV**: Best for importing into Google Sheets, Microsoft Excel, and CRM platforms.
- **JSON / JSONL**: Best for programmatic consumption, custom databases, and backend services.
- **XLSX**: Native Excel format with pre-formatted column headers.
- **XML**: For enterprise legacy pipelines requiring XML schemas.

#### Cloud & Workflow Integrations

Through Apify's native platform integrations, you can route verification results directly to third-party tools:

- **Google Sheets**: Append rows directly to a shared spreadsheet upon run completion.
- **Airtable**: Synchronize verified account status directly with your Airtable base.
- **Slack / Discord**: Receive immediate notifications when large batch verifications finish.
- **Make / Zapier**: Trigger multi-step automated workflows based on verification output.
- **Amazon S3 / Google Cloud Storage**: Automatically archive verification datasets in cloud storage buckets.

***

### Limitations and considerations

- **Account Content & Privacy**: This Actor is designed specifically for account status verification (active versus inactive). It does not scrape private profile media, direct messages, follower lists, or restricted personal details.
- **Private Profiles**: Private profiles that exist and are accessible on Instagram are classified as `active`. Privacy settings restrict post visibility, but the account itself remains active and reachable.
- **Age Restrictions & Geographic Filters**: Accounts configured with specific age gates or regional visibility restrictions may appear inactive if accessed from regions where those restrictions apply.
- **Dynamic Platform Changes**: Social media platforms occasionally update public page availability and display rules. If an unexpected status occurs, running a test with a known active benchmark handle (e.g., `instagram`) helps confirm baseline connectivity.
- **Batch Processing Rate**: Large batches are processed with built-in pacing to maintain consistent, reliable lookups across your account list.

***

### Troubleshooting

| Symptom | Likely Cause | Recommended Action |
|---|---|---|
| **All accounts reported as inactive** | Input contains malformed usernames or unsupported characters | Verify that usernames only contain alphanumeric characters, underscores, and dots. |
| **Specific known active account reported as inactive** | Account was recently renamed, suspended, or regional restriction applies | Check whether the handle was changed or if the account has custom age/country gates. |
| **Actor finishes immediately with 0 items** | Empty or non-array `usernames` parameter provided | Ensure the input JSON includes the `usernames` array with at least one valid string. |
| **Output dataset missing expected columns** | Custom export settings applied in console | Reset the export view to `Overview` or select all default fields in the storage viewer. |
| **Run times out on extremely large input** | Input list contains tens of thousands of accounts in one execution | Divide large lists into smaller batches (e.g., 2,000–5,000 accounts per run) for faster feedback. |

***

### Responsible use and compliance

When conducting account verification:

- Respect individual privacy and platform terms of service.
- Verify only publicly accessible profile identifiers that you have a legitimate business or research interest in evaluating.
- Do not use verification outputs for unsolicited harassment, unauthorized surveillance, or abusive outreach practices.
- Ensure that your data handling practices comply with applicable data protection regulations (such as GDPR, CCPA, and equivalent regional legislation).

***

### Frequently asked questions (FAQ)

#### What criteria determine whether an account is active or inactive?

An account is classified as `active` if its public profile exists, is recognized by Instagram, and can be retrieved. An account is marked as `inactive` if the username does not exist, has been permanently removed, has been deactivated by the user, or is suspended.

#### Does this Actor require my Instagram login or password?

No. The Actor operates entirely without requiring your personal Instagram credentials, passwords, session cookies, or access tokens. Your private credentials remain completely safe and unexposed.

#### Can I pass full Instagram URLs instead of usernames?

Yes. The Actor automatically parses full URLs such as `https://www.instagram.com/username/` and extracts the clean username for verification.

#### How does the Actor treat private accounts?

Private accounts are reported as `active` as long as the account exists and is valid on the platform. The Actor checks account existence, not whether the user's photos and reels are public.

#### How many usernames can I verify in a single run?

There is no hard limit on the number of accounts you can submit in the `usernames` array. For optimal turnaround and manageable datasets, batches between 500 and 5,000 accounts per run are recommended.

#### Can I automate checks on a regular schedule?

Yes. You can use Apify's built-in **Schedules** feature to run the Actor automatically on an hourly, daily, weekly, or custom cron schedule.

#### Are profile owners notified when their account is checked?

No. Checking account status is a passive lookup. The profile owner receives no notification, message, or alert when their account is verified.

#### What should I do if an account was recently active but shows as inactive?

Instagram users frequently change their usernames or temporarily deactivate their profiles for personal breaks. An inactive status indicates that the specific username string requested is currently unavailable on the platform.

#### How are handles with `@` symbols handled?

The Actor automatically detects and strips leading `@` symbols, so both `@handle` and `handle` produce identical, accurate verification results.

#### Can I integrate results directly into my Google Sheets?

Yes. You can use the Apify Google Sheets integration or export the dataset directly as a CSV file to import into your spreadsheet.

***

### Next steps

Ready to clean your contact database and verify your Instagram handles?

1. Add your target accounts to the `usernames` array in the input console.
2. Click **Start** to run the verification.
3. Download your clean `active`/`inactive` dataset in your preferred format.

# Actor input Schema

## `usernames` (type: `array`):

List of Instagram usernames, @handles, or profile URLs to verify.

## Actor input object example

```json
{
  "usernames": [
    "instagram",
    "fnmotol"
  ]
}
```

# 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 = {
    "usernames": [
        "instagram",
        "fnmotol"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("karamelo/instagram-account-checker-active-or-inactive").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 = { "usernames": [
        "instagram",
        "fnmotol",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("karamelo/instagram-account-checker-active-or-inactive").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "usernames": [
    "instagram",
    "fnmotol"
  ]
}' |
apify call karamelo/instagram-account-checker-active-or-inactive --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,karamelo/instagram-account-checker-active-or-inactive"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/6asCfEk8ziaalDGcG/builds/Sdh3nZyGVNhTUsoTs/openapi.json