Which integrations are available for this server?

Provides tools to connect to an Instagram account, check connection status, retrieve a list of accounts you follow that do not follow you back, and disconnect.

How do I use Instagram Relationship MCP?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Instagram Relationship MCP Which accounts do I follow that don't follow me back?" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Instagram Relationship MCP

by rankes96-dev

Overview Schema Related Servers Score Discussions

TypeScript

Local

Instagram Relationship MCP

A local MCP server that answers one question for an Instagram account you control:

Which accounts do I follow that do not follow me back?

The server is read-only toward Instagram. It can sign in through a dedicated Playwright Chromium profile, read relationship data, cache derived results locally, and disconnect. It cannot follow, unfollow, block, like, comment, or send messages.

IMPORTANT

This project uses Instagram's private, unsupported Web API rather than Meta's supported Instagram Graph API. Instagram can change these endpoints without notice. Unknown response shapes fail closed withPRIVATE_API_CHANGED, and rate limits stop the scan. Use only an account you control and comply with Instagram's terms and policies.

How it works

Instagram
    ↑ dedicated authenticated browser profile
Playwright persistent Chromium context
    ↑ same-origin private Web API requests
InstagramWebAdapter
    ↑ normalized relationship records only
RelationshipService + local derived cache
    ↑ business-level MCP results
ChatGPT Work, Codex, or another MCP client

Instagram credentials are entered only in the visible instagram.com browser window. Passwords, cookies, CSRF tokens, request headers, and browser storage are never accepted as MCP arguments or returned in tool results.

Related MCP server: Insta MCP Server

Requirements

Windows 10/11 for the commands shown below. The Node server itself is portable, but the Secure Tunnel walkthrough is Windows/PowerShell focused.
Git
Node.js 24 or newer
A graphical desktop session for Instagram login, 2FA, and challenges
An Instagram account you control
One connection option:
- ChatGPT Work with OpenAI Secure MCP Tunnel, or
- a local MCP client that can launch a stdio server

This package is installed from source; it is not published to npm.

Install

Open PowerShell and run:

git clone https://github.com/rankes96-dev/instagram-relationship-mcp.git
Set-Location instagram-relationship-mcp

npm ci
npm run browser:install
npm run build
npm run check

npm ci installs the exact versions in package-lock.json. Playwright is pinned because every Playwright release expects matching browser binaries. Run npm run browser:install again after changing or updating Playwright.

Choose how to connect

Option A: ChatGPT Work through Secure MCP Tunnel

Use this path to keep the MCP server on your computer while making it available to a ChatGPT developer-mode app. Secure MCP Tunnel uses an outbound HTTPS connection; it does not require a public MCP port or inbound firewall rule.

1. Prepare OpenAI access

Create or inspect a tunnel in OpenAI Platform tunnel settings.
Associate the tunnel with both the Platform organization that owns it and the target ChatGPT workspace. A tunnel associated only with a Platform organization may not appear in ChatGPT Work.
Ensure the operator has the correct Platform permissions:
- Tunnels Read + Manage to create or edit tunnels.
- Tunnels Read + Use to run tunnel-client and select the tunnel in ChatGPT.
Ensure Developer mode is allowed by the ChatGPT workspace policy. In ChatGPT, enable it under Settings → Security and login → Developer mode.
Create a dedicated runtime API key for a user or service account whose Platform organization role has Tunnels Read + Use. Restrict the key where supported. Do not use an admin key for the long-running tunnel process.

See OpenAI's Secure MCP Tunnel guide for the current permission and workspace-association model.

2. Install `tunnel-client`

Download the correct Windows archive from the latest official tunnel-client release, extract it, and place tunnel-client.exe on PATH. Do not hard-code a release URL in an operational runbook.

Verify the binary:

tunnel-client --version
tunnel-client help quickstart

3. Create and validate a local stdio profile

From the repository directory, set the runtime key only in the current PowerShell process and initialize a named profile. Replace the placeholders; never commit the real key or tunnel ID.

$env:CONTROL_PLANE_API_KEY = "<restricted-runtime-api-key>"
$repo = (Resolve-Path .).Path
$mcpCommand = "node `"$repo\scripts\tunnel-mcp-entry.mjs`""

tunnel-client init `
  --sample sample_mcp_stdio_local `
  --profile instagram-relationships `
  --tunnel-id "tunnel_<32-lowercase-hex-characters>" `
  --mcp-command $mcpCommand

tunnel-client doctor --profile instagram-relationships --explain
tunnel-client run --profile instagram-relationships

Keep tunnel-client run running while ChatGPT uses the app. Its local /ui, /healthz, /readyz, and /metrics surfaces show runtime health; the startup output prints the loopback URL.

The tunnel profile must launch scripts/tunnel-mcp-entry.mjs, not dist/index.js directly. The wrapper removes OpenAI control-plane keys before importing the Instagram MCP server, so the Instagram subprocess does not inherit them. Prefer CONTROL_PLANE_API_KEY; OPENAI_API_KEY is only a tunnel-client fallback.

The Instagram server does not load .env automatically. Never put plaintext API keys in a tunnel profile or YAML file; use an env: reference, keep generated profiles outside Git (or ignored), and do not expose keys in command arguments or logs.

4. Add the tunnel in ChatGPT Work

Open ChatGPT Plugins.
Select the plus button and enter a user-facing name and description.
Under Connection, choose Tunnel.
Select the tunnel or paste its tunnel_id.
Create the connection and review the four discovered tools.
Start a new chat and add the connection from the tools menu.

After changing tool names, descriptions, schemas, or annotations, restart the tunnel-backed MCP server, open the connection in ChatGPT Plugins, select Refresh, and test in a new chat.

Option B: local stdio MCP client

For Codex or another local MCP client, build the project and configure the client with absolute paths:

{
  "mcpServers": {
    "instagram-relationships": {
      "command": "node",
      "args": [
        "C:\\absolute\\path\\to\\instagram-relationship-mcp\\dist\\index.js"
      ]
    }
  }
}

A complete example is available at docs/mcp-config.example.json.

The transport is stdio. The server does not bind a port. Standard output is reserved for MCP JSON-RPC; sanitized operational logs go only to standard error.

Use this sequence in ChatGPT or your MCP client:

Call instagram_connect.
If it returns LOGIN_PENDING, complete Instagram login, 2FA, or a challenge only in the visible instagram.com Chromium window.
Call instagram_connection_status until it returns CONNECTED. CHALLENGE_REQUIRED means the visible window still needs action.
Call instagram_get_non_followers.

Never enter an Instagram password, cookie, session ID, CSRF token, or 2FA code into ChatGPT or an MCP tool argument. If a saved session is still valid, instagram_connect may return connected: true without opening a window.

MCP tools

`instagram_connect`

Reuses a verified saved session or opens one visible Chromium window and returns promptly with LOGIN_PENDING. Repeated calls while login is pending reuse the same attempt rather than opening another browser.

`instagram_connection_status`

Performs one bounded session check. It can return CONNECTED, LOGIN_PENDING, NOT_CONNECTED, SESSION_EXPIRED, LOGIN_REQUIRED, or CHALLENGE_REQUIRED. Once interactive login succeeds, it confirms that the saved profile also works in the background before reporting CONNECTED.

`instagram_get_non_followers`

Fetches Following pages, deduplicates numeric Instagram user IDs, checks relationship statuses in bounded batches, and returns only users with explicit followed_by === false status.

Inputs:

refresh (optional boolean): ignore a fresh derived cache and scan again.
limit (optional integer, 1–100): number of users to return; default 50.
cursor (optional string): opaque signed cursor returned by the previous page. Do not combine it with refresh: true.

The result states whether it came from live or cache, when it was computed, whether the scan is complete, and how many statuses remain UNKNOWN. A partial fetch is never presented as a complete result.

`instagram_disconnect`

Closes Chromium, securely removes the dedicated browser profile, and purges local account metadata and cached relationship data. The next Instagram operation requires manual login again.

Configuration

All settings are optional. Supply them through the MCP client's environment or the operating system. The server does not load .env automatically.

Variable	Default	Allowed values
`INSTAGRAM_MCP_DATA_DIR`	`%LOCALAPPDATA%\InstagramRelationshipMcp`	Absolute local directory
`INSTAGRAM_MCP_CACHE_TTL_MINUTES`	`15`	`1`–`1440`
`INSTAGRAM_MCP_FOLLOWING_PAGE_SIZE`	`12`	`1`–`200`
`INSTAGRAM_MCP_RELATIONSHIP_BATCH_SIZE`	`12`	`1`–`200`
`INSTAGRAM_MCP_RESULT_PAGE_SIZE`	`50`	`1`–`100`
`INSTAGRAM_MCP_LOGIN_TIMEOUT_SECONDS`	`300`	`30`–`1800`
`INSTAGRAM_MCP_NAVIGATION_TIMEOUT_SECONDS`	`45`	`5`–`180`
`INSTAGRAM_MCP_REQUEST_TIMEOUT_SECONDS`	`30`	`5`–`120`
`INSTAGRAM_MCP_INTER_REQUEST_DELAY_MS`	`250`	`0`–`10000`
`INSTAGRAM_MCP_NETWORK_RETRIES`	`1`	`0`–`3`
`INSTAGRAM_MCP_MAX_FOLLOWING_PAGES`	`10000`	`1`–`100000`
`INSTAGRAM_MCP_LOG_LEVEL`	`info`	`debug`, `info`, `warn`, `error`, `silent`

See .env.example as an environment-variable reference only; copying it to .env has no effect. Put values in the MCP client's env block or set them in the process that launches the server, for example:

$env:INSTAGRAM_MCP_LOG_LEVEL = "debug"
npm start

Batch sizes are runtime settings, not claimed Instagram API limits.

Local data and security

By default, data is stored outside the repository:

%LOCALAPPDATA%\InstagramRelationshipMcp\
├── instagram-profile\
└── instagram.db

The dedicated browser profile contains Instagram authentication state. The SQLite database stores only account metadata, normalized users, and derived relationship scans. Do not point INSTAGRAM_MCP_DATA_DIR at your normal Chrome profile, this repository, a synchronized folder, or a shared directory.

Never commit or share:

.env or runtime API keys
tunnel IDs or tunnel-client profiles
the Playwright browser profile
SQLite database, WAL, or SHM files
cookies, headers, HAR files, screenshots, or network dumps
tunnel or MCP logs containing private account context

The included .gitignore excludes these local artifacts, but ignore rules are not an access-control boundary. See SECURITY.md for the threat model and safe diagnostics policy.

Update

Stop the foreground tunnel process, then run:

git pull
npm ci
npm run browser:install
npm run check
tunnel-client run --profile instagram-relationships

The browser profile and database live outside the repository and survive source updates unless instagram_disconnect is called. Refresh the ChatGPT developer-mode connection after MCP metadata changes.

Development

npm run build
npm test
npm run smoke:mcp
npm run check
npm run inspect

npm run check builds the project, runs every test, and runs the stdio smoke test.
npm run smoke:mcp builds and verifies both legacy stdio and MCP 2026-07-28 without opening a browser.
Run npm run build before npm run inspect; the Inspector uses dist/index.js.
Browser and live-account scenarios require manual testing with an account you control. Automated tests use sanitized synthetic fixtures and contain no production credentials or usernames.

Troubleshooting

The tunnel is not visible in ChatGPT

Confirm that the tunnel is associated with the target ChatGPT workspace—not only a Platform organization—and that the app creator has Tunnels Read + Use. Developer mode must also be permitted by workspace policy.

ChatGPT cannot discover or call tools

Keep tunnel-client run --profile instagram-relationships running, then execute:

tunnel-client doctor --profile instagram-relationships --explain

Check the loopback /ui and ensure health, readiness, and the main MCP channel are green. If metadata is stale, refresh the connection in ChatGPT Plugins and start a new chat.

No Instagram window opens

Run npm run browser:install, confirm a graphical desktop session is active, and call instagram_connect again. A valid saved session may intentionally connect without a visible window.

The result remains `LOGIN_PENDING`

Finish the visible browser flow, then call instagram_connection_status. Do not repeatedly start new connections. If the browser was closed, call instagram_connect once to start a fresh attempt.

Instagram reports a rate limit or private API change

Stop and wait after INSTAGRAM_RATE_LIMITED; do not retry aggressively. PRIVATE_API_CHANGED means the expected private response contract no longer matches and requires a reviewed code update, not a guessed parser fallback.

Licensing and reference boundary

No software license is currently included. Source availability on GitHub does not grant an open-source reuse license.

IG-Cleaner was reviewed only for the general idea of manual local login and a dedicated persistent browser profile. This is a clean-room implementation and does not copy IG-Cleaner's Selenium, DOM-scrolling, username-comparison, or write-action design.

Available Tools

4 tools

instagram_connectConnect InstagramA

Idempotent

Use this when the user wants to connect Instagram or resume an unfinished local login. It reuses a verified saved session; otherwise it opens the dedicated local Chromium profile and returns immediately with LOGIN_PENDING. Credentials, 2FA, and challenge responses must be entered only on instagram.com; then use instagram_connection_status.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description reveals concrete behaviors beyond the annotations: reuse of a verified saved session, opening a dedicated local Chromium profile, returning immediately with LOGIN_PENDING, and requiring credentials to be entered only on instagram.com. These details significantly enrich the agent's understanding of what happens when invoked.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences, front-loaded with the usage condition, and every sentence contributes unique information (when to use, what happens, where credentials go). No redundancy or unnecessary detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given that the tool has no parameters and an output schema exists (which likely documents the return structure), the description covers all essential contextual aspects: session reuse, browser launch, immediate LOGIN_PENDING, and the required follow-up action with instagram_connection_status. It is complete for a connection-initiating tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there are no parameter details to add. With 0 params, the baseline is 4, and the description appropriately does not attempt to explain parameters, making it fully sufficient.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific use case: 'Use this when the user wants to connect Instagram or resume an unfinished local login.' It clearly identifies the resource (Instagram) and the action (connect), and distinguishes itself from sibling tools by noting that the user should 'then use instagram_connection_status' for status checks.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It provides an explicit trigger condition ('Use this when...') and instructs the user to follow up with instagram_connection_status. However, it does not explicitly state when not to use this tool or directly compare with alternatives like instagram_disconnect or instagram_get_non_followers, so it's clear but lacks explicit exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

instagram_connection_statusInstagram Connection StatusA

Idempotent

Use this when the user wants to check whether Instagram is connected, especially after instagram_connect returned LOGIN_PENDING. It reports the current login or session state and never asks for credentials.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description adds context by stating it 'reports the current login or session state' and 'never asks for credentials,' providing safety-relevant behavior beyond the annotations. Annotations already hint at idempotency and non-destructiveness, and the description does not contradict them.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the primary use case. Every sentence adds value: one tells when to use it, the other clarifies what it reports and that it doesn't ask for credentials. No redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (no params) and the presence of an output schema, the description adequately covers the core behavior and usage context. It mentions the important LOGIN_PENDING scenario and the credential-avoidance behavior, providing sufficient completeness for an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the input schema confirms this with 100% coverage. The description does not need to add parameter semantics, and per the rubric, a tool with 0 params receives a baseline of 4, which is appropriate here.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool checks whether Instagram is connected and reports the current login/session state. This specific verb+resource combination distinguishes it from sibling tools like instagram_connect and instagram_disconnect.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says to use this when checking connection status, especially after instagram_connect returned LOGIN_PENDING. It provides clear context but does not explicitly state when not to use it or mention alternatives beyond the implied distinction from connect/disconnect.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

instagram_disconnectDisconnect InstagramA

DestructiveIdempotent

Closes Chromium and permanently deletes the dedicated Instagram browser profile plus locally derived account and relationship data.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.3/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare destructive and not read-only. The description adds specific context beyond annotations: it closes Chromium, permanently deletes the profile, and removes locally derived account and relationship data. This clarifies exactly what is destroyed without contradicting annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

One concise sentence at 17 words, front-loaded with the main action ('Closes Chromium') and followed by the destructive scope. Every word earns its place with no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter tool with an output schema, the description adequately covers the side effects (closing Chromium) and the full scope of data deletion. It provides enough information for an agent to decide to invoke it without needing return-value details.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the schema has no properties. The baseline for zero parameters is 4, and the description does not need to add parameter details. No deduction necessary.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific action: closes Chromium and permanently deletes the Instagram browser profile plus locally derived account and relationship data. This clearly distinguishes it from siblings like instagram_connect and instagram_get_non_followers, which serve different purposes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not explicitly state when to use this tool or mention alternatives. The verb 'disconnect' implies usage for disconnecting, but there is no explicit guidance comparing it to connect/status tools. Usage is only implied.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

instagram_get_non_followersGet Instagram Non-FollowersA

Returns accounts the connected user follows that explicitly do not follow the user back. Fetches a complete Following list before classification, reports unknown statuses, caches normalized results locally, and paginates MCP output.

ParametersJSON Schema

Name	Required	Description
`limit`	No	Number of users to return. Defaults to 50; maximum 100.
`cursor`	No	Opaque nextCursor returned by a previous result page.
`refresh`	No	Set true to ignore a fresh cache and scan Instagram again.

Output Schema

ParametersJSON Schema

Name	Required	Description
No output parameters

TDQS

A4.5/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses key behavioral traits: it fetches a complete Following list before classification, reports unknown statuses, caches normalized results locally, and paginates MCP output. These go well beyond the annotations, which only indicate readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false. The caching detail aligns with the readOnlyHint=false, and the pagination is useful context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, dense sentence that front-loads the core purpose and then adds behavioral context in one sweep. Every clause contributes information without redundancy, making it both concise and structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With a full input schema, an output schema, and annotations, the description still adds necessary context: the complete fetch, local caching, unknown statuses, and pagination. This covers the operational behavior and potential performance implications, making it complete for an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description does not add parameter-specific semantics, but it mentions pagination and caching, which indirectly relate to the cursor and refresh parameters. Since the schema already fully documents each parameter, the description adds marginal value but does not need to compensate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource: 'Returns accounts the connected user follows that explicitly do not follow the user back.' This clearly states what the tool does and differentiates it from sibling tools like instagram_connect and instagram_disconnect, which are about connection management.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

While there is no explicit 'use when' or exclusion statement, the description makes the tool's purpose unambiguous and its context (Instagram non-followers) clear. The sibling tools are distinct, so the intended usage is evident even without an explicit alternative pointer.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.4/5.0

Disambiguation5/5

Each tool has a distinct role: connect initiates login, status checks login state, get_non_followers performs the main analysis, and disconnect cleans up. There is no overlap or ambiguity between them.

Naming Consistency4/5

All tools share the 'instagram_' prefix, but the verb usage is slightly inconsistent: 'connect' and 'disconnect' are bare verbs, 'connection_status' is a noun phrase, and 'get_non_followers' uses a get_ prefix. Overall the pattern is readable and predictable.

Tool Count5/5

With 4 tools, the server is well-scoped for its specific purpose of managing Instagram relationships. Each tool is necessary and none feel redundant.

Completeness4/5

The set covers the full lifecycle from connect to disconnect, with the core non-follower analysis in between. Minor gaps exist, such as no explicit refresh action or follow/unfollow operations, but these are outside the stated purpose.

Maintenance

ActivityMaintained

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

GTM API: LinkedIn MCP Server
com.gtm-api
Managed LinkedIn MCP server for AI agents: search, connect, message and enrich on accounts you own.
Social Media Communication
15
Probe V0 A
io.github.lexbritten
Experimental MCP server for current empirical verification of explicit public HTTPS endpoint claims.
API Testing Penetration Testing
21
thoughts
ai.thoughtbox.api
An MCP server that provides read access to your cloud storage providers, bank accounts and more.
Cloud Storage Finance
2
Tap
io.github.LeonTing1010
Browser MCP for logged-in tasks. Uses your Chrome — credentials stay local. Zero-token replay.
Browser Automation Web Scraping
217

Related MCP Servers

Instagram MCP Server
Browser Automation Web Scraping Social Media
duhlink
F
license
B
quality
D
maintenance
A server that allows fetching Instagram posts using Chrome's existing login session via Model Context Protocol (MCP).
Updated 2 years ago (2025-01-09 08:34 UTC)
1
50
Insta MCP Server
Social Media App Automation Communication
anand-kamble
A
license
A
quality
D
maintenance
MCP server that enables integration with Instagram, allowing interaction with Instagram features through the Model Context Protocol.
Updated 9 months ago (2025-11-24 02:14 UTC)
15
28
8
MIT
instagram-personal-mcp
Social Media Communication
AleemHaider
A
license
Not graded
quality
D
maintenance
An MCP server that wraps instagrapi to read, engage, and send DMs from a personal Instagram account, supporting 24 tools for auth, profile, engagement, and messages.
Updated 4 months ago (2026-05-15 06:46 UTC)
MIT
Instagram Control MCP Server
Social Media Communication
official-Arvind
A
license
B
quality
A
maintenance
A professional, full-fidelity MCP server enabling AI agents to fully control and manage an Instagram account exactly like a human user.
Updated 2 months ago (2026-06-20 14:16 UTC)
68
4
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/rankes96-dev/instagram-relationship-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

Instagram Relationship MCP

How it works

Requirements

Install

Choose how to connect

Option A: ChatGPT Work through Secure MCP Tunnel

1. Prepare OpenAI access

2. Install tunnel-client

3. Create and validate a local stdio profile

4. Add the tunnel in ChatGPT Work

Option B: local stdio MCP client

First login and first scan

MCP tools

instagram_connect

instagram_connection_status

instagram_get_non_followers

instagram_disconnect

Configuration

Local data and security

Update

Development

Troubleshooting

The tunnel is not visible in ChatGPT

ChatGPT cannot discover or call tools

No Instagram window opens

The result remains LOGIN_PENDING

Instagram reports a rate limit or private API change

Licensing and reference boundary

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

2. Install `tunnel-client`

`instagram_connect`

`instagram_connection_status`

`instagram_get_non_followers`

`instagram_disconnect`

The result remains `LOGIN_PENDING`