# Instagram Tagged Posts (`opspilot.cc/instagram-tagged-posts`) Actor

🏷️ Instagram Tagged Posts | Who tags you, and how well those posts perform Give it your own accounts (or any account) and get every post that tags it — with the posting account on every row, plus likes, comments and time.

- **URL**: https://apify.com/opspilot.cc/instagram-tagged-posts.md
- **Developed by:** [wang wei](https://apify.com/opspilot.cc) (community)
- **Security:** Limited permissions
- **Stats:** 44 total users, 17 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.005 / actor start

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

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

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

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

# README

## 🏷️ Instagram Tagged Posts

> Every post that tags a given account — with the posting account on every row.

### ✨ What you get

One dataset row per tagged post:

| Field | What it is |
|---|---|
| `postShortcode` / `url` | the post that does the tagging |
| **`postedBy` / `postedByUserId`** | **the account that tagged you** — the reason to run this Actor |
| `subjectAccount` | which of your accounts got tagged |
| `likeCount` / `commentCount` | how well that post performed |
| `caption` / `takenAt` / `isVideo` | content and timing |
| `displayUrl` | cover image |

The run summary adds, per subject account: posts collected, the account's own reported tag total, whether more pages exist, how many **unique accounts** tagged it, median likes, and a **top-5 poster ranking** (posts + likes per tagging account).

### 💼 Use cases

- **Turning taggers into your UGC shortlist** — every row carries `postedBy` and `postedByUserId`, so the dataset is a mention list, not just a post list. Sort by poster and the summary's top-5 ranking gives you accounts tagging you repeatedly, ranked by posts and likes.
- **Rewarding the creators already working for you** — an account tagged 5 times with 14,035 likes on one post is a partner who has already proven the placement works. That is a renewal conversation with evidence in it.
- **Measuring a brand partnership's footprint** — put your own handle in the input list and the unique-account count plus median likes tell you how many distinct creators picked you up, and how well those placements performed.
- **Watching a tagged-post spike after a campaign** — run the Actor on a schedule and diff `postedBy`. A burst of new posters after a launch is the clearest signal that a placement landed.

### ✅ Who this is for

- **Social and community managers**— whose brand gets tagged constantly and who need to find the accounts doing it most, rather than scrolling the tagged tab.
- **Partnerships and BD teams**— turning organic taggers into a renewal or paid roster with per-post engagement already attached.
- **UGC programmes**— identifying creators who have already produced content for you, which is the cheapest place to start a paid relationship.
- **Agencies managing several brand accounts**— who can put up to 30 handles in one run and get a separate poster ranking per subject.

### ❌ Who this is NOT for

- **Caption mentions only** — this includes every post that tags the account, including tags inside the photo itself. If you only want caption mentions, filter the `caption` column for your handle after export.
- **Accounts that have never been tagged, and private accounts** — both produce nothing and are listed in `warnings`. No rows is not a bug in your filter.
- **Taking the reported tag total literally** — that counter is Instagram's own approximation and it is possible to collect 25 rows against a reported "of 21". Read it as indicative, and treat `hasMorePages` as the real signal that history remains.
- **A full tag archive** — history depth is capped at `maxPostsPerSubject` (1–200, default 42), following Instagram's roughly 21-post pages. An account tagged 2,000 times will never be fully in the dataset.
- **A brand-mention monitoring tool across the web, or another platform** — this reads Instagram's tagged-posts endpoint for Instagram accounts only. It is not a listening tool for X, TikTok, YouTube or Google Business reviews, and it carries no sentiment or share-of-voice metric.

### 🚀 Quick start

1. Open the Actor and press **Start** (defaults to `instagram`, 42 posts).
2. Put your own handle in the list — the poster ranking in the summary is your UGC/creator shortlist.
3. Raise `maxPostsPerSubject` to walk further back; the Actor pages through Instagram's cursor.

### 📥 Input parameters

| Parameter | Type | Default | What it does |
|---|---|---|---|
| `usernames` | list | `instagram` | Accounts to look up tagged posts for. Handles, profile URLs and numeric ids, up to 30 per run. |
| `maxPostsPerSubject` | number | `42` | 1–200 tagged posts per account. Instagram returns about 21 per page and this Actor follows the cursor through them. Cost scales linearly with posts × accounts. |

### 📤 Output

- **Dataset** — one row per tagged post (or a notice when nothing was collected)
- **SUMMARY** — per-account poster rankings, request counts and warnings

#### Example item

```json
{
  "postShortcode": "BrGHMHIF8Kz",
  "subjectAccount": "natgeo",
  "postedBy": "hynecheck",
  "postedByUserId": "99",
  "caption": "Vardzia cave monastery",
  "likeCount": 14035,
  "commentCount": 582,
  "isVideo": false,
  "takenAt": 1544205867,
  "displayUrl": "https://scontent.cdninstagram.com/…",
  "url": "https://www.instagram.com/p/BrGHMHIF8Kz/",
  "collectedAt": "2026-10-04T08:30:00.000Z"
}
```

### ⚙️ How it works

1. Each input is resolved to a numeric id (handles and URLs go through a profile lookup).
2. Tagged posts are paged through Instagram's own cursor until the cap or the end of the history.
3. Every row keeps the posting account, so the output is a mention list, not just a post list.
4. The summary aggregates by poster, which is the actionable view.

### 💰 Billing

Pay per result — you are charged for the tagged-post rows this Actor actually returns, not for the run. Accounts with no tags are not charged. Cost scales linearly with posts × accounts. There is no daily run cap.

### ❓ FAQ

**Does this include posts where my account is tagged in the photo?**
Yes — that is exactly what "tagged posts" means on Instagram. If you want only caption mentions, filter the `caption` column for your handle after export.

**How deep does the history go?**
As deep as you allow: Instagram pages about 21 posts at a time and this Actor follows the cursor up to your cap (200 posts per account).

**The summary says "of 21" — what is that?**
The number of tagged posts the account itself reports. If you collected 25 of 21, the counter is Instagram's own approximation; treat it as indicative.

**Nothing was collected for my account. Why?**
Either the account has never been tagged, or it is private. Both cases are listed in `warnings`.

**How do I find who tagged me most usefully?**
Sort the dataset by `postedBy` and check the run summary's top posters — accounts tagging you repeatedly with good engagement are your most promising UGC or partnership candidates.

### 📚 Resources

- Instagram tagged-posts endpoints (no login required)
- Apify free plan: monthly credit covers usage, no separate daily cap

# Changelog

This Actor's version history is a separate document: https://apify.com/opspilot.cc/instagram-tagged-posts/changelog.md

# Actor input Schema

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

The accounts to look up tagged posts for — one per line, up to 30 per run.

## `maxPostsPerSubject` (type: `integer`):

How many tagged posts to collect per account. Instagram returns about 21 per page and this Actor pages through them. Cost scales linearly with posts × accounts.

## Actor input object example

```json
{
  "usernames": [
    "instagram"
  ],
  "maxPostsPerSubject": 42
}
```

# Actor output Schema

## `dataset` (type: `string`):

One row per tagged post, or a single notice when nothing was collected.

## `summary` (type: `string`):

Per-account poster rankings, request counts and warnings.

# 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("opspilot.cc/instagram-tagged-posts").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("opspilot.cc/instagram-tagged-posts").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 '{}' |
apify call opspilot.cc/instagram-tagged-posts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,opspilot.cc/instagram-tagged-posts"
        }
    }
}
```

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/8kpaM4zbewmc8FWNu/builds/FyC8nfBKQVhuAKHuk/openapi.json