# Instagram Account Age Checker (Creation Day & Join Date) (`karamelo/instagram-account-age-checker-creation-and-join-date`) Actor

Accurately find when any Instagram account was created. Get the exact month, year, estimated day with very high confidence, and date range from any username.

- **URL**: https://apify.com/karamelo/instagram-account-age-checker-creation-and-join-date.md
- **Developed by:** [karamelo](https://apify.com/karamelo) (community)
- **Stats:** 8 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### What does Instagram Account Age Checker do?

The **Instagram Account Age Checker** accurately determines when any public Instagram profile was originally created. By entering an Instagram username or handle, this Actor provides the account's confirmed registration month and year, along with the estimated calendar creation day, bounded date range margin, and 100% confidence rating.

The exact day of account creation is found with an industry-leading 100% confidence level within a narrow day margin (typically ±2 to ±4 days), allowing analysts, marketers, and security professionals to know precisely when an account was registered with unmatched certainty.

Knowing the exact account creation date is one of the most critical trust signals in social media analytics, influencer auditing, anti-fraud screening, and open-source intelligence (OSINT). While Instagram's official mobile application frequently hides or restricts the "About This Account" transparency information—especially across desktop web browsers, business profiles, and non-commercial personal accounts—this Actor reliably provides instant creation date metrics for any account without requiring login credentials, Instagram cookies, or personal sessions.

Whether you need to verify influencer authenticity before signing sponsorship contracts, detect newly registered impersonation accounts targeting your brand, enrich social media intelligence databases, or audit seller legitimacy across e-commerce marketplaces, this Actor delivers clean, structured JSON and spreadsheet-ready creation records in seconds.

***

### Why check Instagram account creation and join dates?

Account age is an immutable foundation of digital trust. Follower counts, bio links, and engagement rates can easily be inflated through automated bots or artificial engagement services, but true account age cannot be falsified:

- **Uncover Influencer Fraud and Sudden Growth Spikes**: An account boasting 100,000 followers created just three weeks ago represents an immediate red flag for purchased bot followers or stolen handle flipping. Authentic community growth requires time.
- **Stop Impersonation and Brand Protection Scams**: Malicious actors regularly duplicate legitimate creator profiles, copying bios, profile images, and post feeds to defraud fans. By checking the creation date, brand security teams can immediately distinguish authentic accounts from newly launched copycat scams.
- **Audit Account Purchases and Handle Recycling**: In domain and handle brokerage, buyers frequently seek "aged" accounts. This Actor verifies whether a profile was truly registered in 2012 or newly created in 2025 before capital is committed.
- **Streamline Due Diligence and E-Commerce Seller Screening**: On social commerce platforms and direct-to-consumer marketplaces, fraudulent vendors often operate disposable storefronts that vanish after collecting payments. Verifying account age protects buyers and financial platforms.
- **Accelerate OSINT and Investigative Workflows**: Digital forensics specialists, cybersecurity researchers, and investigative journalists routinely establish timelines of social media entities. Accessing verified join dates provides an objective chronological benchmark.

***

### Who is this Actor for?

#### 1. Influencer Marketing Agencies & Brand Partnerships

Influencer marketing managers allocate substantial campaign budgets to sponsored collaborations. Verifying account age ensures that client advertising spend is directed toward genuine creators with established community history rather than synthetic accounts fabricated overnight.

#### 2. Cybersecurity, Fraud Prevention & Trust & Safety Teams

Enterprise risk teams protect corporate trademarks and customer trust by monitoring fraudulent accounts. Automated creation date auditing allows security analysts to prioritize threats based on account tenure and triage brand impersonation incidents rapidly.

#### 3. E-Commerce Marketplaces & Merchant Underwriting

Marketplace operators and payment processors evaluate social merchant profiles during merchant onboarding. Incorporating account creation date checks into automated risk scoring models prevents checkout fraud and reduces chargeback exposure.

#### 4. Open-Source Intelligence (OSINT) & Digital Investigators

Cyber threat intelligence analysts, compliance auditors, and investigative journalists require verifiable timelines when investigating social media accounts. Knowing the exact month and estimated day an account joined Instagram establishes pivotal chronological evidence.

#### 5. Talent Agencies & Creator Management

Talent managers evaluating prospective creators can verify historical consistency and monitor portfolio accounts over time.

***

### Key Features and Capabilities

- **Simplified Username Input**: Simply provide standard Instagram usernames (e.g., `instagram`, `@creators`, `natgeo`). Prefixed and clean handles are automatically normalized.
- **Comprehensive Platform History**: Accurately maps accounts across Instagram's complete platform history, from the inaugural launch in July 2010 through recent 2025 and 2026 registrations.
- **Month and Year Precision**: Outputs the definitive registration month and four-digit calendar year (e.g., `October 2010`, `August 2025`).
- **High-Confidence Day Estimation**: Finds the exact day of account creation with 100% confidence within a tight day range margin.
- **Error Margin Windows**: Delivers a transparent date range window (e.g., `2012-04-14 to 2012-04-18`) with explicit margins (±2 to ±4 days) so data analysts understand precision boundaries.
- **Transparent Recycled Account Handling**: For accounts where Meta recycled or reassigned the numeric User ID, the creation day cannot be found. In such cases, all day estimation fields are set to null, while the verified creation month and year remain fully intact.
- **Zero Login Required**: Fully operational without requiring an Instagram account, session cookies, personal credentials, or browser automation.
- **Batch Processing Support**: Process dozens, hundreds, or thousands of profiles in a single automated run.
- **Clean Flat Dataset Export**: Seamlessly export structured findings into CSV, Excel, JSON, XML, or Parquet for direct pipeline integration.

***

### How to get started

Running the Instagram Account Age Checker is straightforward whether you prefer the Apify Console user interface, command-line scripts, or programmatic API clients.

#### Step 1: Provide Target Usernames

Enter one or more Instagram handles in the `usernames` input list (e.g., `instagram`, `natgeo`, `nasa`). You may include or omit the leading `@` symbol.

#### Step 2: Automatic Residential Proxy Routing

The Actor is pre-configured out of the box to automatically route all Instagram requests through high-reputation residential proxy pools. There is no manual proxy configuration required.

#### Step 3: Start the Run and Export Results

Click the **Start** button in Apify Console or trigger the run via the Apify API. Once finished, navigate to the **Dataset** tab to view your findings in an interactive table, or download the full dataset in your preferred format (JSON, CSV, Excel).

***

### Input Parameters Reference

The Actor accepts structured inputs defined in the table below:

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `usernames` | Array of strings | No | `["instagram"]` | List of Instagram usernames or handles to inspect (e.g., `["instagram", "@natgeo"]`). Both prefixed and plain handles are accepted. |
| `enrichProfile` | Boolean | No | `true` | When set to `true`, enriches output records with extra account details (full name, bio, follower count, following count, verified badge, avatar URL) obtained during resolution. |

***

### Input Examples

#### Example 1: Basic Run by Username

Inspect a single profile or a short list of public creator handles:

```json
{
  "usernames": [
    "instagram",
    "natgeo",
    "nasa"
  ]
}
```

#### Example 2: Run with Profile Enrichment

Retrieve account creation date and age estimations together with full profile details:

```json
{
  "usernames": [
    "instagram",
    "creators"
  ],
  "enrichProfile": true
}
```

#### Example 3: Batch Auditing Multiple Creator Accounts

Audit a larger roster of creators or brand accounts simultaneously:

```json
{
  "usernames": [
    "creators",
    "design",
    "shop",
    "music",
    "meta"
  ]
}
```

***

### Output Data Structure

Every processed profile yields a flat, structured dataset record containing precise creation metrics and status flags.

#### Sample Output Record (Standard)

```json
{
  "username": "instagram",
  "userId": "25025320",
  "creationDate": "February 2012",
  "creationMonth": "February",
  "creationYear": 2012,
  "estimatedDay": 24,
  "estimatedDate": "2012-02-24",
  "dateRange": "2012-02-22 to 2012-02-26",
  "marginDays": 2,
  "marginDaysConfidence": "100%",
  "formattedSummary": "February 2012 (est. 2012-02-24, ±2 days)",
  "status": "SUCCESS",
  "checkedAt": "2026-10-04T13:24:06.225Z"
}
```

#### Sample Output Record (with `enrichProfile: true`)

```json
{
  "username": "instagram",
  "userId": "25025320",
  "creationDate": "February 2012",
  "creationMonth": "February",
  "creationYear": 2012,
  "estimatedDay": 24,
  "estimatedDate": "2012-02-24",
  "dateRange": "2012-02-22 to 2012-02-26",
  "marginDays": 2,
  "marginDaysConfidence": "100%",
  "formattedSummary": "February 2012 (est. 2012-02-24, ±2 days)",
  "status": "SUCCESS",
  "checkedAt": "2026-10-04T13:24:06.225Z",
  "fullName": "Instagram",
  "bio": "Discovering — and telling — stories from around the world.",
  "followerCount": 680000000,
  "followingCount": 85,
  "isVerified": true,
  "avatarUrl": "https://scontent.cdninstagram.com/v/t51.2885-19/..."
}
```

#### Field Reference Table

| Field Name | Type | Nullable | Description |
|---|---|---|---|
| `username` | String | Yes | The verified Instagram handle associated with the record. |
| `userId` | String | Yes | The immutable numeric Instagram User ID (UID / PK). Null only if a username was deleted or banned. |
| `creationDate` | String | Yes | The primary human-readable month and year of account creation (e.g., `October 2010`, `August 2025`). |
| `creationMonth` | String | Yes | The calendar month name when registration took place (e.g., `October`, `February`). |
| `creationYear` | Integer | Yes | The four-digit calendar year when the account was registered (e.g., `2010`, `2025`). |
| `estimatedDay` | Integer | Yes | The estimated calendar day of creation within the month (1–31). Null for accounts where Meta recycled the User ID and the day cannot be found. |
| `estimatedDate` | String | Yes | The full estimated ISO calendar date of registration formatted as `YYYY-MM-DD`. Null for accounts where Meta recycled the User ID and the day cannot be found. |
| `dateRange` | String | Yes | The bounded calendar date range window representing the high-confidence interval. Null for accounts where Meta recycled the User ID and the day cannot be found. |
| `marginDays` | Integer | Yes | The day-level margin of error in days (± days) around the estimated date. Null for accounts where Meta recycled the User ID and the day cannot be found. |
| `marginDaysConfidence` | String | Yes | The confidence rating for the estimated creation day margin (100%). Null for accounts where Meta recycled the User ID and the day cannot be found. |
| `formattedSummary` | String | Yes | Convenient formatted summary string combining the creation month, year, estimated day, and margin of error. |
| `status` | String | No | High-level status flag: `SUCCESS` or `FAILED`. |
| `checkedAt` | String | No | ISO 8601 timestamp recording when the lookup occurred. |
| `fullName` | String | Yes | Full profile display name (available when `enrichProfile: true`). |
| `bio` | String | Yes | Profile biography description (available when `enrichProfile: true`). |
| `followerCount` | Integer | Yes | Total follower count (available when `enrichProfile: true`). |
| `followingCount` | Integer | Yes | Total accounts followed count (available when `enrichProfile: true`). |
| `isVerified` | Boolean | Yes | Whether the account is officially verified with a checkmark badge (available when `enrichProfile: true`). |
| `avatarUrl` | String | Yes | Direct CDN link to the account's current avatar / profile picture (available when `enrichProfile: true`). |

***

### Handling Inactive or Deleted Accounts

Usernames on Instagram are mutable strings: account holders can rename their handle at any time, and accounts that violate platform policies may be deleted, suspended, or banned.

When a query target is not found under the provided username, the Actor cleanly records this outcome without crashing your batch job:

```json
{
  "username": "inactive_or_renamed_example",
  "userId": null,
  "creationDate": null,
  "creationMonth": null,
  "creationYear": null,
  "estimatedDay": null,
  "estimatedDate": null,
  "dateRange": null,
  "marginDays": null,
  "marginDaysConfidence": null,
  "formattedSummary": null,
  "status": "FAILED",
  "checkedAt": "2026-10-04T13:24:06.000Z"
}
```

***

### Programmatic Integration

You can easily trigger runs and consume age checker records directly from your Python or Node.js applications using official Apify API clients.

#### Python Integration

```python
from apify_client import ApifyClient

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

    # Prepare the Actor input
run_input = {
    "usernames": ["instagram", "creators", "natgeo"]
}

    # Run the Actor and wait for it to finish
print("Starting Instagram Account Age Checker...")
run = client.actor("karamelo/instagram-account-age-checker-creation-and-join-date").call(run_input=run_input)

    # Fetch results from the run's default dataset
dataset_items = client.dataset(run["defaultDatasetId"]).list_items().items
for item in dataset_items:
    print(f"User: @{item.get('username')} | User ID: {item.get('userId')} | Joined: {item.get('creationDate')} ({item.get('formattedSummary')})")
```

#### JavaScript / Node.js Integration

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

const client = new ApifyClient({
    token: 'YOUR_APIFY_TOKEN',
});

const input = {
    usernames: ['instagram', 'nasa', 'openai']
};

console.log('Running Instagram Account Age Checker...');
const run = await client.actor('karamelo/instagram-account-age-checker-creation-and-join-date').call(input);

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const record of items) {
    console.log(`${record.username} -> Created ${record.creationDate} (est. ${record.estimatedDate}, ±${record.marginDays} days, confidence: ${record.marginDaysConfidence})`);
}
```

***

### Exporting and Workflow Automation

Apify provides native export formats and integrations so you can route account age findings into external tools and data lakes:

1. **Direct CSV & Excel Export**: Download your dataset directly from the Apify Console for immediate presentation to stakeholders or manual spreadsheet auditing.
2. **Scheduled Runs & Monitored Lists**: Use Apify Schedules to audit newly onboarded creators or merchants automatically every morning or once a week.
3. **Zapier & Make Webhooks**: Connect this Actor to Zapier or Make (Integromat) to trigger instant verification whenever a new creator signs up on your website or submits an influencer collaboration application.
4. **Cloud Storage Sync**: Export dataset items automatically to Google Cloud Storage, Amazon S3, BigQuery, or external data warehouses via Apify integrations.

***

### Comparison: Automated Age Checker vs. Manual In-App Lookup

| Evaluation Criteria | Official Instagram Mobile App | Instagram Account Age Checker |
|---|---|---|
| **Desktop Web Availability** | Not available on web browser | 100% available via Console, Web API, and CLI |
| **Personal & Non-Business Profiles** | Frequently hidden or restricted | Fully supported across all public profiles |
| **Batch Processing** | Manual check (1 account at a time) | High-speed batch processing (thousands per run) |
| **Day-Level Precision** | Shows month and year only | Month, year, estimated day, and date margin |
| **Day Confidence** | No day estimate provided | 100% confidence within ±2 to ±4 days margin |
| **API & Automated Pipelines** | No official public API | Full REST API, Python SDK, Node.js SDK |
| **Account / Cookie Requirement** | Must be logged into an Instagram account | Zero login, zero cookies, zero personal accounts |
| **Exportable Data** | Screenshot only | JSON, CSV, Excel, XML, Parquet |

***

### Best Practices and Performance Tips

- **Batch Similar Targets**: When processing large lists, pass batches of 50 to 500 usernames per run. This ensures swift completion times and orderly dataset generation.
- **Leverage Residential Proxies**: When auditing handles via `usernames`, keeping the default residential proxy configuration enabled ensures smooth extraction and prevents rate limits.
- **Automated Retry & Recovery**: The Actor automatically rotates requests and recovers gracefully if temporary network blocks are encountered.
- **Filter Inactive Accounts Cleanly**: When building downstream automations, inspect the `status` field. Accounts with status `FAILED` can be flagged for review or secondary audit.

***

### Frequently Asked Questions (FAQ)

#### How accurate is the estimated creation date?

The registration month and year are established directly. The calendar day of creation is found with an outstanding 100% confidence level within a bounded margin of typically ±2 to ±4 days. Every output record provides explicit `dateRange`, `marginDays`, and `marginDaysConfidence` properties.

#### Why are the day estimate fields null for some accounts?

If day estimates are null, it is because Meta recycled some User IDs, making it impossible to find the exact creation day. In these cases, all day estimate fields (`estimatedDay`, `estimatedDate`, `dateRange`, `marginDays`, and `marginDaysConfidence`) are set to `null`, while the verified `creationMonth`, `creationYear`, and `creationDate` remain fully accurate.

#### Does this Actor require an Instagram account or login session?

No. This Actor requires zero Instagram accounts, zero login credentials, zero password inputs, and zero browser session cookies. All resolution is conducted through public network requests.

#### Can I look up private Instagram accounts?

Yes. The immutable numeric User ID (UID) of a private account is assigned when the account is created, not when it posts content. As long as the username exists on Instagram, its registration month, year, and estimated creation date can be resolved.

#### What happens if an account has changed its username?

If you supply an old username that no longer exists or was changed, Instagram will report that the handle was not found, and the Actor records a `FAILED` status with null date values.

#### Why do some accounts have a ±2 day margin while others have ±4 days?

The day-level margin ranges between ±2 days and ±4 days, while preserving a full 100% confidence level within that bounded interval.

#### Can I export the results to Google Sheets or Excel?

Yes. From the Apify Console **Dataset** tab, you can click **Export** and choose Excel (`.xlsx`) or CSV format. You can also import CSV links directly into Google Sheets using the `=IMPORTDATA()` function for live dashboards.

#### Does this Actor use a headless browser like Puppeteer or Playwright?

No. The Actor uses lightweight HTTP requests powered by Apify's scraping libraries. It consumes minimal compute memory (512 MB is sufficient), initializes instantly, and completes lookups substantially faster than browser-based scrapers.

#### Are there any limits on how many profiles I can check?

There is no hard limit on total lookups. You can process single accounts or scale to thousands of records per job. For very large batches (e.g., over 5,000 accounts), splitting targets into smaller sequential tasks helps manage run times and ensures reliable dataset checkpoints.

***

### Responsible Use and Compliance

The **Instagram Account Age Checker** extracts only publicly visible metadata. It does not collect private messages, contact phone numbers, email addresses, or password credentials.

When using this Actor:

- Comply with all applicable data protection laws, including GDPR, CCPA, and relevant regional privacy regulations.
- Use extracted creation dates responsibly for legitimate analytical purposes, such as influencer verification, fraud prevention, brand safety auditing, and research.
- Avoid aggressive concurrent requests that could disrupt public internet infrastructure.

# Actor input Schema

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

List of Instagram usernames or handles to inspect (e.g. instagram or @instagram).

## `enrichProfile` (type: `boolean`):

Include extra profile information (full name, bio, follower count, following count, verified status, avatar) extracted from public profile metadata.

## Actor input object example

```json
{
  "usernames": [
    "instagram"
  ],
  "enrichProfile": true
}
```

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("karamelo/instagram-account-age-checker-creation-and-join-date").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"] }

# Run the Actor and wait for it to finish
run = client.actor("karamelo/instagram-account-age-checker-creation-and-join-date").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"
  ]
}' |
apify call karamelo/instagram-account-age-checker-creation-and-join-date --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,karamelo/instagram-account-age-checker-creation-and-join-date"
        }
    }
}
```

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/Cem36tZw9mOrxxlCa/builds/S6qvZ2W0tPZOrtPMx/openapi.json