# Instagram Related Creator Network (`data-slayer/instagram-related-creator-network`) Actor

Expand Instagram seed profiles into a bounded, deduplicated creator graph with recommendation edges, seed provenance, depth, and optional public profile details. No Instagram login required.

- **URL**: https://apify.com/data-slayer/instagram-related-creator-network.md
- **Developed by:** [Data Slayer](https://apify.com/data-slayer) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 processed network expansions

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

## Instagram Related Creator Network

Turn Instagram profiles you already know into a bounded, exportable creator network with deduplicated profiles, recommendation edges, depth, and seed provenance.

### Watch the demo

YouTube video coming soon.

### What this Actor does

Instagram Related Creator Network expands one or more public Instagram seed profiles into the related profiles observed around them at run time.

Unlike a flat related-profile list, the Actor can follow connections outward across several levels. It produces an auditable graph of unique creator profiles and the source-to-target connections that reached them.

Use it to map creator niches, find adjacent accounts for partnership research, explore competitor ecosystems, or prepare a focused creator shortlist for later qualification.

### Key features

- Start from 1–10 Instagram usernames or profile URLs
- Expand 1–3 levels with stable breadth-first traversal
- Set separate limits for processed profiles and unique creator nodes
- Keep each distinct recommendation edge, even when several seeds reach the same profile
- Avoid repeat processing and infinite loops when the graph contains cycles
- Keep useful branches when another profile is unavailable
- Optionally add more public details to final kept profiles
- Export creator nodes and graph edges in analysis-friendly formats
- No Instagram login or cookies required

### Quick start

1. Add one or more public Instagram usernames or profile URLs under **Seed profiles**.
2. Choose the network depth. Use `1` for direct connections, `2` to expand direct connections once, or `3` for one additional level.
3. Set **Profiles to expand** and **Creator node limit** to control processing and output size independently.
4. Leave enrichment off for a fast graph, or enable it when you need more public profile details.
5. Start the run and download the creator dataset and edge files.

### Input

| Field | Type | Default | Description |
|---|---|---:|---|
| `seedProfiles` | string array | required | 1–10 Instagram usernames or profile URLs. Duplicate seeds are normalized and processed once. |
| `maxDepth` | integer | `2` | Maximum graph depth from 1–3. Seeds are depth 0; depth 1 is direct connections. |
| `maxExpansions` | integer | `10` | Maximum unique profiles processed for additional connections, including seeds and unavailable profiles. |
| `maxCreators` | integer | `100` | Maximum globally unique creator nodes, including seed nodes. |
| `maxConnectionsPerProfile` | integer | `10` | Keep the first 1–20 valid connections from each processed profile. |
| `enrichProfiles` | boolean | `false` | Add more public profile details to final kept, non-seed nodes after traversal. |
| `maxEnrichedProfiles` | integer | `50` | Maximum kept profiles to enrich. Ignored when enrichment is off. |

#### Example input

```json
{
  "seedProfiles": ["patagonia"],
  "maxDepth": 2,
  "maxExpansions": 10,
  "maxCreators": 100,
  "maxConnectionsPerProfile": 10,
  "enrichProfiles": false,
  "maxEnrichedProfiles": 50
}
```

### Output package

> **Contract status:** Implemented and locally verified. The examples below are sanitized illustrations of the implemented output contract; they are not presented as a live Store run.

The output package has three coordinated deliverables. The default dataset contains one row per unique creator node and is downloadable as JSON or CSV. Recommendation edges are saved separately as `EDGES.json` and `EDGES.csv`. `RUN_SUMMARY` contains run status, counts, limits, per-seed outcomes, per-expansion outcomes, and download URLs.

#### Creator-node dataset

The primary row identity is `creator_id`. Reaching the same creator from several sources or seeds updates one node row and preserves all distinct edges.

| Field | Type / nullability | Unit or meaning |
|---|---|---|
| `record_type` | string, always `creator_node` | Row discriminator |
| `creator_id` | string | Stable creator ID; primary row identity |
| `username` | string | Normalized Instagram username |
| `profile_url` | URL string | Derived public profile URL |
| `full_name` | string or null | Public display name |
| `profile_image_url` | URL string or null | Public image URL; may expire |
| `is_private` | boolean or null | Public privacy flag when available |
| `is_verified` | boolean or null | Public verification flag when available |
| `is_seed` | boolean | Whether the row was supplied as a seed |
| `minimum_depth` | integer | Shortest distance from any seed, in graph hops |
| `seed_usernames` | string array | Seeds that reached this node |
| `first_discovered_from` | string or null | First parent username; null for a seed |
| `first_suggestion_rank` | integer or null | One-based first-observed rank; null for a seed |
| `incoming_edge_count` | integer | Distinct retained incoming edges in this bounded graph |
| `outgoing_edge_count` | integer | Distinct retained outgoing edges in this bounded graph |
| `expansion_status` | enum string | `expanded`, `expanded_no_connections`, `not_expanded_depth`, `not_expanded_limit`, `profile_unavailable`, or `temporarily_unavailable` |
| `enrichment_status` | enum string | `not_enabled`, `not_selected_limit`, `saved`, `profile_unavailable`, or `temporarily_unavailable` |
| `biography` | string or null | Optional public biography |
| `follower_count` | integer or null | Followers, in accounts |
| `following_count` | integer or null | Accounts followed, in accounts |
| `media_count` | integer or null | Published media items, in items |
| `is_business` | boolean or null | Optional public business flag |
| `category` | string or null | Optional public category |
| `public_email` | string or null | Optional publicly listed email |
| `public_phone_number` | string or null | Optional publicly listed phone number |
| `external_url` | URL string or null | Optional publicly listed external URL |
| `observed_at` | ISO 8601 UTC string | Time the row was observed or derived |
| `is_partial` | boolean | True when an attempted expansion or enrichment was incomplete |

#### Recommendation-edge export

The edge identity is the ordered pair `(source_creator_id, target_creator_id)`. Exact duplicate edges are suppressed; a connection reached from several seeds keeps the merged `seed_usernames` array.

| Field | Type | Unit or meaning |
|---|---|---|
| `record_type` | string, always `recommendation_edge` | Row discriminator |
| `source_creator_id` | string | Source creator ID |
| `source_username` | string | Source username |
| `target_creator_id` | string | Target creator ID |
| `target_username` | string | Target username |
| `source_depth` | integer | Source distance from a seed, in graph hops |
| `target_depth` | integer | Target distance from a seed, in graph hops |
| `suggestion_rank` | integer | One-based position in the observed recommendation list |
| `seed_usernames` | string array | Seeds whose traversal retained the edge |
| `relationship_type` | string, always `related_profile` | Relationship discriminator |
| `observed_at` | ISO 8601 UTC string | Observation time |

#### Run summary

| Object | Fields |
|---|---|
| Top level | `contract_version`, `status`, `started_at`, `finished_at` |
| `requested` | Echo of all normalized public input fields |
| `counts` | Seeds, completed and charged expansions, nodes, edges, merged duplicates, cycles, and enrichment totals |
| `limits` | Booleans for expansion, creator, enrichment, and spending-limit stops |
| `seeds[]` | Input, normalized username, functional status, nodes reached, edges observed, stable error code, and safe message |
| `expansions[]` | Creator ID, username, depth, terminal status, connections observed and retained, stable error code, and safe message |
| `downloads` | JSON and CSV URLs for creator nodes and edges, plus the summary URL |

Run status is one of `succeeded`, `succeeded_with_partial_results`, `no_results`, `failed_input`, or `spending_limit_reached`. Public error codes are limited to `PROFILE_UNAVAILABLE`, `DATA_TEMPORARILY_UNAVAILABLE`, `RATE_LIMITED_TRY_LATER`, `REQUEST_TIMED_OUT`, `INVALID_RESPONSE`, and `SPENDING_LIMIT_REACHED`; successful entries use null. Messages are functional and sanitized.

#### Abridged illustrative JSON row

```json
{
  "record_type": "creator_node",
  "creator_id": "1000000002",
  "username": "related_creator",
  "profile_url": "https://www.instagram.com/related_creator/",
  "is_seed": false,
  "minimum_depth": 1,
  "seed_usernames": ["seed_creator"],
  "first_discovered_from": "seed_creator",
  "first_suggestion_rank": 1,
  "incoming_edge_count": 1,
  "outgoing_edge_count": 0,
  "expansion_status": "not_expanded_limit",
  "enrichment_status": "not_enabled",
  "observed_at": "2026-09-20T00:00:00Z",
  "is_partial": false
}
```

The complete schema and illustrative node, edge, and summary examples are shipped with this Actor. Creator rows are also represented in `example-output.csv`, and edges in `EDGES.example.csv`. A successful saved expansion is the billing unit; creator rows and edge rows are deliverables and are not billing events. No raw service responses, private request URLs, authentication details, or internal diagnostics are included in customer outputs.

### How traversal and limits work

Traversal is breadth-first and deterministic. Seed order is preserved, and each profile’s connections are considered in the order observed.

`maxExpansions` limits how many unique profiles are processed for more connections. `maxCreators` limits unique nodes. They are separate because a sparse or partially unavailable graph can consume processing work without producing many new nodes, while a dense graph can reach the node limit early.

The same profile may be reached from several sources or seeds. It appears once in the creator dataset, while each distinct connection is retained. Cycles are recorded as connections but never placed back into the processing queue.

### Optional enrichment

Enrichment is disabled by default. When enabled, it runs after traversal for final kept non-seed nodes only, in breadth-first discovery order, up to `maxEnrichedProfiles`.

Duplicates, invalid records, cycle-only candidates, and profiles excluded by graph caps are not enriched. If one profile cannot be enriched, its creator node remains in the graph with a stable functional status and no enrichment charge.

### Pricing

The primary billing unit is a **network expansion**, not a creator node or edge. One expansion means one profile was processed to a saved terminal status and its retained graph connections were saved. Completed no-result and unavailable-profile checks count as expansion work; temporary service failures that never complete are not charged.

Optional enrichment is billed only when additional public profile details are successfully saved. There is also the standard small Actor-start event. Nodes, edges, downloads, and the run summary have no separate charge.

| Plan | Actor start | Network expansion | Saved enriched profile |
|---|---:|---:|---:|
| Free | $0.0005 | $0.015 | unavailable |
| Bronze | $0.0005 | $0.012 | $0.0035 |
| Silver | $0.0005 | $0.010 | $0.003 |
| Gold | $0.0005 | $0.008 | $0.0025 |
| Platinum | $0.0005 | $0.008 | $0.0025 |
| Diamond | $0.0005 | $0.008 | $0.0025 |

Free-plan runs are limited to three expansions, no enrichment, and one run per rolling 24 hours. Paid plans use the limits selected in the input.

These rates are selected for launch preparation but are not live yet. Once released, check the Actor’s Pricing tab before running.

### Important limitations

- Results are related-profile connections observed at run time, not a demographic or audience-overlap score.
- The graph is bounded by the limits you choose and is not a complete database of Instagram creators.
- Related profiles and public profile fields can change over time.
- Private, unavailable, renamed, or removed profiles may return limited data or a functional status instead of profile details.
- A higher connection limit changes graph breadth but does not reduce completed expansion work.
- Use public data responsibly and comply with applicable laws, platform terms, and your own outreach obligations.

### Common use cases

- Creator and influencer niche mapping
- Partnership and sponsorship research
- Competitor ecosystem analysis
- Multi-seed related-profile exploration
- Graph analysis in spreadsheets, notebooks, or network tools
- Building a focused shortlist for a separate qualification workflow

### API and automation

Run the Actor from Apify Console, the Apify API, schedules, webhooks, or supported integrations. Use a maximum run charge to keep automated workflows within budget. The Actor stops starting new paid work when the platform reports that the customer limit has been reached.

### Responsible use

Use public data lawfully and in line with Instagram’s terms and applicable privacy rules. Do not use this Actor to infer sensitive traits or make unsupported claims about a person’s audience or demographics.

This independent Actor is not affiliated with, endorsed by, or an official product of Instagram.

### Support

For reproducible support requests, include the Apify run ID, sanitized input, the affected deliverable, and the functional status shown by the Actor. Never include credentials or private customer data.

# Actor input Schema

## `seedProfiles` (type: `array`):

Instagram usernames or profile URLs to use as starting points. Enter 1–10 unique profiles.

## `maxDepth` (type: `integer`):

How far to expand from the seeds. 1 returns direct connections; 2 can expand those connections once; 3 goes one level further.

## `maxExpansions` (type: `integer`):

Maximum unique profiles processed for more connections, including seed profiles and unavailable profiles. Must be at least the number of unique seeds.

## `maxCreators` (type: `integer`):

Maximum unique profiles in the finished network, including seed profiles. Must be at least the number of unique seeds.

## `maxConnectionsPerProfile` (type: `integer`):

Keep the first 1–20 valid connections from each processed profile. A lower value creates a narrower graph but does not reduce expansion work already completed.

## `enrichProfiles` (type: `boolean`):

Add more public details to kept, non-seed creator nodes after traversal and deduplication. Disabled by default to keep runs predictable.

## `maxEnrichedProfiles` (type: `integer`):

Maximum kept, non-seed creator nodes to enrich in breadth-first order. Ignored when enrichment is disabled.

## Actor input object example

```json
{
  "seedProfiles": [
    "patagonia"
  ],
  "maxDepth": 2,
  "maxExpansions": 10,
  "maxCreators": 100,
  "maxConnectionsPerProfile": 10,
  "enrichProfiles": false,
  "maxEnrichedProfiles": 50
}
```

# Actor output Schema

## `creator_nodes` (type: `string`):

One row per unique creator in the bounded graph.

## `creator_nodes_table` (type: `string`):

Default table view for JSON, CSV, and spreadsheet export.

## `recommendation_edges_json` (type: `string`):

Directed recommendation connections retained in the graph.

## `recommendation_edges_csv` (type: `string`):

The same directed edge records in CSV format.

## `run_summary` (type: `string`):

Counts, caps, per-seed outcomes, per-expansion statuses, and direct download URLs.

# 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 = {
    "seedProfiles": [
        "patagonia"
    ],
    "maxDepth": 2,
    "maxExpansions": 10,
    "maxCreators": 100,
    "maxConnectionsPerProfile": 10,
    "maxEnrichedProfiles": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("data-slayer/instagram-related-creator-network").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 = {
    "seedProfiles": ["patagonia"],
    "maxDepth": 2,
    "maxExpansions": 10,
    "maxCreators": 100,
    "maxConnectionsPerProfile": 10,
    "maxEnrichedProfiles": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("data-slayer/instagram-related-creator-network").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 '{
  "seedProfiles": [
    "patagonia"
  ],
  "maxDepth": 2,
  "maxExpansions": 10,
  "maxCreators": 100,
  "maxConnectionsPerProfile": 10,
  "maxEnrichedProfiles": 50
}' |
apify call data-slayer/instagram-related-creator-network --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data-slayer/instagram-related-creator-network"
        }
    }
}
```

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/YAHidg1gTca8pcwhu/builds/RuVxhw12fHkcpzeyG/openapi.json