# Instagram MCP Server — Profiles, Posts & Hashtags for AI (`sleeze22/instagram-mcp-server`) Actor

MCP server for AI agents to search Instagram users, get profile details, browse posts, explore hashtags, and get post details. 6 tools. Works with Claude, ChatGPT, Cursor, and any MCP client. No Instagram API key needed. Pay per tool call.

- **URL**: https://apify.com/sleeze22/instagram-mcp-server.md
- **Developed by:** [zSleezeh](https://apify.com/sleeze22) (community)
- **Categories:** Social media, AI, Agents
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Instagram MCP Server — Profiles, Posts & Hashtags for AI Agents

**Connect AI assistants to Instagram data via MCP.** 6 tools for searching users, browsing profiles, getting posts, exploring hashtags, and retrieving post details. No Instagram API key needed. Works with Claude Desktop, Claude Code, ChatGPT, Cursor, Windsurf, and any MCP-compatible client.

### What does Instagram MCP Server do?

Instagram MCP Server is a **Model Context Protocol (MCP) server** that gives AI agents real-time access to public Instagram data. It exposes 6 specialized tools that let AI assistants search for users, retrieve profile details (bio, followers, posts count), browse recent posts with engagement metrics, explore hashtag trends, and get detailed post information including captions, likes, comments, and tagged users.

Built on the Apify platform, it supports **Streamable HTTP transport**, stateless requests, and automatic scaling. You get pay-per-event billing — you only pay when tools are actually called.

### Why use Instagram MCP Server?

- **Social media research** — Analyze influencer profiles, track follower counts, compare engagement rates
- **Content monitoring** — Monitor hashtag trends, track brand mentions, discover trending content
- **Competitive analysis** — Research competitor Instagram presence and content strategy
- **Lead generation** — Find relevant profiles in your industry, research potential partners
- **Market research** — Explore hashtag popularity, understand audience interests
- **Content inspiration** — Browse top-performing posts in your niche

### How to use Instagram MCP Server

1. **Get your Apify API token** from [Apify Console → Settings → API & Integrations](https://console.apify.com/settings/integrations)
2. **Add the MCP server** to your AI client:

#### Claude Desktop / Claude Code

Add a custom connector in Settings → MCP Servers and paste:

````

https://YOUR\_USERNAME--instagram-mcp-server.apify.actor/mcp?token=YOUR\_APIFY\_TOKEN

````

Replace `YOUR_USERNAME` with your Apify username and `YOUR_APIFY_TOKEN` with your [Apify API token](https://console.apify.com/settings/integrations).

#### Cursor / Windsurf / Other MCP clients

Add to your MCP config:

```json
{
  "mcpServers": {
    "instagram": {
      "url": "https://YOUR_USERNAME--instagram-mcp-server.apify.actor/mcp?token=YOUR_APIFY_TOKEN"
    }
  }
}
````

3. **Start using it** — Ask your AI assistant things like "Search for fitness influencers on Instagram" or "Show me recent posts from @natgeo"

### Available MCP Tools

| Tool | Description | Price |
|------|-------------|-------|
| `instagram_search_users` | Search users by name or username | $0.005 |
| `instagram_get_profile` | Get full profile details (bio, followers, posts count) | $0.008 |
| `instagram_get_posts` | Get recent posts with engagement metrics | $0.01 |
| `instagram_explore_hashtag` | Explore top posts for a hashtag | $0.01 |
| `instagram_get_post` | Get detailed info about a specific post | $0.008 |
| `instagram_search_hashtags` | Search hashtags with post counts | $0.005 |

### Output examples

#### Profile lookup

```
Username: @natgeo
Full name: National Geographic
Bio: Experience the world through the eyes of National Geographic photographers.
Followers: 283,000,000
Following: 156
Posts: 28,432
Verified: Yes
Private: No
Website: natgeo.com
Category: Media/News Company
```

#### Post detail

```
Post by @natgeo
Type: Photo
Caption: A polar bear surveys the Arctic landscape...
Likes: 1,245,678
Comments: 4,532
Date: 2025-07-08
URL: https://www.instagram.com/p/CxYz123/
Location: Svalbard, Norway
```

### Pricing

Pay-per-event billing — you only pay when tools are called. No monthly fees.

- **Search operations**: $0.005 per call (~200 searches for $1)
- **Profile lookups**: $0.008 per call (~125 lookups for $1)
- **Post retrieval**: $0.01 per call (~100 retrievals for $1)

Apify offers a free tier to get started. Typical research session (10-20 tool calls) costs $0.05-0.15.

### Tips

- Use `instagram_search_users` first to find usernames, then `instagram_get_profile` for details
- Combine `instagram_get_posts` with profile data for engagement rate analysis
- Use shortcodes or full URLs with `instagram_get_post`
- Private accounts return limited data — search results still show follower counts

### Running locally

```bash
npm install
npm run start:dev
```

Server starts at `http://localhost:3000/mcp`

### Deploy to Apify

```bash
apify login
apify push
```

Your MCP server will be live at `https://YOUR_USERNAME--instagram-mcp-server.apify.actor/mcp`

### FAQ

**Is this legal?** This server accesses publicly available Instagram data only. It does not access private profiles, bypass authentication, or violate Instagram's Terms of Service.

**Do I need an Instagram account?** No. The server works without any Instagram credentials.

**What about rate limits?** The server includes retry logic with exponential backoff. Apify handles scaling automatically.

**Need a custom solution?** Check the Issues tab or contact the developer for custom Instagram data requirements.

### Resources

- [What is Anthropic's Model Context Protocol?](https://blog.apify.com/what-is-model-context-protocol/)
- [How to use MCP with Apify Actors](https://blog.apify.com/how-to-use-mcp/)
- [Webinar: Building and monetizing MCP servers on Apify](https://www.youtube.com/watch?v=w3AH3jIrXXo)
- [Apify MCP server documentation](https://docs.apify.com/platform/integrations/mcp)

# Actor input Schema

## Actor input object example

```json
{}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("sleeze22/instagram-mcp-server").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("sleeze22/instagram-mcp-server").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 '{}' |
apify call sleeze22/instagram-mcp-server --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sleeze22/instagram-mcp-server",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram MCP Server — Profiles, Posts & Hashtags for AI",
        "description": "MCP server for AI agents to search Instagram users, get profile details, browse posts, explore hashtags, and get post details. 6 tools. Works with Claude, ChatGPT, Cursor, and any MCP client. No Instagram API key needed. Pay per tool call.",
        "version": "0.0",
        "x-build-id": "pnBUu4C0xznDEsFXk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sleeze22~instagram-mcp-server/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sleeze22-instagram-mcp-server",
                "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/sleeze22~instagram-mcp-server/runs": {
            "post": {
                "operationId": "runs-sync-sleeze22-instagram-mcp-server",
                "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/sleeze22~instagram-mcp-server/run-sync": {
            "post": {
                "operationId": "run-sync-sleeze22-instagram-mcp-server",
                "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": {}
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```