Instagram API

Schedule and automate Instagram posts with RelayAPI — feed posts, carousels, stories, reels, collaborators, and user tags.

Quick Reference

Property	Value
Platform key	`instagram`
Auth method	OAuth 2.0 (via Facebook Business)
Character limit	2,200 (caption)
Images per post	1 (feed), 10 (carousel)
Videos per post	1
Image formats	JPEG, PNG
Image max size	8 MB (auto-compressed)
Video formats	MP4, MOV
Video max size	300 MB (feed/reels), 100 MB (stories)
Video max duration	90 sec (reels), 60 min (feed), 60 sec (story)
Post types	Feed, Carousel, Story, Reel
Scheduling	Yes
Analytics	Yes (impressions, reach, likes, comments, shares, saves, views)

SDK source — TypeScript · Python · Go · Java · REST API

Instagram requires a Business or Creator account — personal accounts cannot post via the API. Media is required for all Instagram posts; there are no text-only posts. Google Drive, Dropbox, and OneDrive URLs do not work as media sources because they return HTML pages, not raw media bytes. Always use direct CDN URLs. Instagram enforces a hard limit of 100 posts per 24-hour rolling window across all content types.

Quick Start

Post a photo to your Instagram feed:

import Relay from '@relayapi/sdk';
const client = new Relay();

const post = await client.posts.create({
  content: 'Beautiful sunset today #photography',
  targets: ['instagram'],
  media: [
    { url: 'https://cdn.example.com/sunset.jpg', type: 'image' },
  ],
  scheduled_at: 'now',
});

console.log(post.id); // post_abc123

from relay import Relay

client = Relay()

post = client.posts.create(
    content='Beautiful sunset today #photography',
    targets=['instagram'],
    media=[
        {'url': 'https://cdn.example.com/sunset.jpg', 'type': 'image'},
    ],
    scheduled_at='now',
)

print(post.id)  # post_abc123

client := relaygo.NewClient()

post, err := client.Posts.New(context.TODO(), relaygo.PostNewParams{
    Content:     relaygo.F("Beautiful sunset today #photography"),
    Targets:     relaygo.F([]string{"instagram"}),
    ScheduledAt: relaygo.F("now"),
    Media: relaygo.F([]relaygo.PostNewParamsMedia{
        {URL: relaygo.F("https://cdn.example.com/sunset.jpg"), Type: relaygo.F(relaygo.PostNewParamsMediaTypeImage)},
    }),
})

fmt.Println(post.ID) // post_abc123

RelayClient client = RelayOkHttpClient.fromEnv();

PostCreateResponse post = client.posts().create(PostCreateParams.builder()
    .content("Beautiful sunset today #photography")
    .addTarget("instagram")
    .addMedia(PostCreateParams.Media.builder()
        .url("https://cdn.example.com/sunset.jpg")
        .type(PostCreateParams.Media.Type.IMAGE)
        .build())
    .scheduledAt("now")
    .build());

System.out.println(post.id()); // post_abc123

curl -X POST https://api.relayapi.dev/v1/posts \
  -H "Authorization: Bearer $RELAY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Beautiful sunset today #photography",
    "targets": ["instagram"],
    "media": [
      {"url": "https://cdn.example.com/sunset.jpg", "type": "image"}
    ],
    "scheduled_at": "now"
  }'

Content Types

Feed Post (Single Image)

A single image post on the Instagram feed. Only the first 125 characters are visible before the "more" fold.

const post = await client.posts.create({
  content: 'Beautiful sunset today #photography',
  targets: ['instagram'],
  media: [
    { url: 'https://cdn.example.com/sunset.jpg', type: 'image' },
  ],
  scheduled_at: 'now',
});

post = client.posts.create(
    content='Beautiful sunset today #photography',
    targets=['instagram'],
    media=[
        {'url': 'https://cdn.example.com/sunset.jpg', 'type': 'image'},
    ],
    scheduled_at='now',
)

post, err := client.Posts.New(context.TODO(), relaygo.PostNewParams{
    Content:     relaygo.F("Beautiful sunset today #photography"),
    Targets:     relaygo.F([]string{"instagram"}),
    ScheduledAt: relaygo.F("now"),
    Media: relaygo.F([]relaygo.PostNewParamsMedia{
        {URL: relaygo.F("https://cdn.example.com/sunset.jpg"), Type: relaygo.F(relaygo.PostNewParamsMediaTypeImage)},
    }),
})

PostCreateResponse post = client.posts().create(PostCreateParams.builder()
    .content("Beautiful sunset today #photography")
    .addTarget("instagram")
    .addMedia(PostCreateParams.Media.builder()
        .url("https://cdn.example.com/sunset.jpg")
        .type(PostCreateParams.Media.Type.IMAGE)
        .build())
    .scheduledAt("now")
    .build());

curl -X POST https://api.relayapi.dev/v1/posts \
  -H "Authorization: Bearer $RELAY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Beautiful sunset today #photography",
    "targets": ["instagram"],
    "media": [
      {"url": "https://cdn.example.com/sunset.jpg", "type": "image"}
    ],
    "scheduled_at": "now"
  }'

Carousel (Up to 10 Images/Videos)

Mix images and videos in a swipeable carousel. The first item determines the aspect ratio for all items.

const post = await client.posts.create({
  content: 'Trip highlights from last weekend',
  targets: ['instagram'],
  media: [
    { url: 'https://cdn.example.com/photo1.jpg', type: 'image' },
    { url: 'https://cdn.example.com/photo2.jpg', type: 'image' },
    { url: 'https://cdn.example.com/clip.mp4', type: 'video' },
    { url: 'https://cdn.example.com/photo3.jpg', type: 'image' },
  ],
  scheduled_at: 'now',
});

post = client.posts.create(
    content='Trip highlights from last weekend',
    targets=['instagram'],
    media=[
        {'url': 'https://cdn.example.com/photo1.jpg', 'type': 'image'},
        {'url': 'https://cdn.example.com/photo2.jpg', 'type': 'image'},
        {'url': 'https://cdn.example.com/clip.mp4', 'type': 'video'},
        {'url': 'https://cdn.example.com/photo3.jpg', 'type': 'image'},
    ],
    scheduled_at='now',
)

post, err := client.Posts.New(context.TODO(), relaygo.PostNewParams{
    Content:     relaygo.F("Trip highlights from last weekend"),
    Targets:     relaygo.F([]string{"instagram"}),
    ScheduledAt: relaygo.F("now"),
    Media: relaygo.F([]relaygo.PostNewParamsMedia{
        {URL: relaygo.F("https://cdn.example.com/photo1.jpg"), Type: relaygo.F(relaygo.PostNewParamsMediaTypeImage)},
        {URL: relaygo.F("https://cdn.example.com/photo2.jpg"), Type: relaygo.F(relaygo.PostNewParamsMediaTypeImage)},
        {URL: relaygo.F("https://cdn.example.com/clip.mp4"), Type: relaygo.F(relaygo.PostNewParamsMediaTypeVideo)},
        {URL: relaygo.F("https://cdn.example.com/photo3.jpg"), Type: relaygo.F(relaygo.PostNewParamsMediaTypeImage)},
    }),
})

PostCreateResponse post = client.posts().create(PostCreateParams.builder()
    .content("Trip highlights from last weekend")
    .addTarget("instagram")
    .addMedia(PostCreateParams.Media.builder()
        .url("https://cdn.example.com/photo1.jpg")
        .type(PostCreateParams.Media.Type.IMAGE)
        .build())
    .addMedia(PostCreateParams.Media.builder()
        .url("https://cdn.example.com/photo2.jpg")
        .type(PostCreateParams.Media.Type.IMAGE)
        .build())
    .addMedia(PostCreateParams.Media.builder()
        .url("https://cdn.example.com/clip.mp4")
        .type(PostCreateParams.Media.Type.VIDEO)
        .build())
    .addMedia(PostCreateParams.Media.builder()
        .url("https://cdn.example.com/photo3.jpg")
        .type(PostCreateParams.Media.Type.IMAGE)
        .build())
    .scheduledAt("now")
    .build());

curl -X POST https://api.relayapi.dev/v1/posts \
  -H "Authorization: Bearer $RELAY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Trip highlights from last weekend",
    "targets": ["instagram"],
    "media": [
      {"url": "https://cdn.example.com/photo1.jpg", "type": "image"},
      {"url": "https://cdn.example.com/photo2.jpg", "type": "image"},
      {"url": "https://cdn.example.com/clip.mp4", "type": "video"},
      {"url": "https://cdn.example.com/photo3.jpg", "type": "image"}
    ],
    "scheduled_at": "now"
  }'

Story

Stories are ephemeral (24 hours). Text captions are not displayed on stories. Link stickers are not available via the API.

const post = await client.posts.create({
  targets: ['instagram'],
  media: [
    { url: 'https://cdn.example.com/story.jpg', type: 'image' },
  ],
  scheduled_at: 'now',
  target_options: {
    instagram: {
      content_type: 'story',
    },
  },
});

post = client.posts.create(
    targets=['instagram'],
    media=[
        {'url': 'https://cdn.example.com/story.jpg', 'type': 'image'},
    ],
    scheduled_at='now',
    target_options={
        'instagram': {
            'content_type': 'story',
        },
    },
)

post, err := client.Posts.New(context.TODO(), relaygo.PostNewParams{
    Targets:     relaygo.F([]string{"instagram"}),
    ScheduledAt: relaygo.F("now"),
    Media: relaygo.F([]relaygo.PostNewParamsMedia{
        {URL: relaygo.F("https://cdn.example.com/story.jpg"), Type: relaygo.F(relaygo.PostNewParamsMediaTypeImage)},
    }),
    TargetOptions: relaygo.F(map[string]interface{}{
        "instagram": map[string]interface{}{
            "content_type": "story",
        },
    }),
})

PostCreateResponse post = client.posts().create(PostCreateParams.builder()
    .addTarget("instagram")
    .addMedia(PostCreateParams.Media.builder()
        .url("https://cdn.example.com/story.jpg")
        .type(PostCreateParams.Media.Type.IMAGE)
        .build())
    .scheduledAt("now")
    .targetOptions(PostCreateParams.TargetOptions.builder()
        .putAdditionalProperty("instagram", JsonValue.from(Map.of(
            "content_type", "story"
        )))
        .build())
    .build());

curl -X POST https://api.relayapi.dev/v1/posts \
  -H "Authorization: Bearer $RELAY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "targets": ["instagram"],
    "media": [
      {"url": "https://cdn.example.com/story.jpg", "type": "image"}
    ],
    "scheduled_at": "now",
    "target_options": {
      "instagram": {
        "content_type": "story"
      }
    }
  }'

Reel

Vertical video (9:16), max 90 seconds. Reels appear on the Reels tab and optionally on your profile feed.

const post = await client.posts.create({
  content: 'New tutorial!',
  targets: ['instagram'],
  media: [
    { url: 'https://cdn.example.com/reel.mp4', type: 'video' },
  ],
  scheduled_at: 'now',
  target_options: {
    instagram: {
      content_type: 'reels',
      share_to_feed: true,
      first_comment: 'Link in bio!',
    },
  },
});

post = client.posts.create(
    content='New tutorial!',
    targets=['instagram'],
    media=[
        {'url': 'https://cdn.example.com/reel.mp4', 'type': 'video'},
    ],
    scheduled_at='now',
    target_options={
        'instagram': {
            'content_type': 'reels',
            'share_to_feed': True,
            'first_comment': 'Link in bio!',
        },
    },
)

post, err := client.Posts.New(context.TODO(), relaygo.PostNewParams{
    Content:     relaygo.F("New tutorial!"),
    Targets:     relaygo.F([]string{"instagram"}),
    ScheduledAt: relaygo.F("now"),
    Media: relaygo.F([]relaygo.PostNewParamsMedia{
        {URL: relaygo.F("https://cdn.example.com/reel.mp4"), Type: relaygo.F(relaygo.PostNewParamsMediaTypeVideo)},
    }),
    TargetOptions: relaygo.F(map[string]interface{}{
        "instagram": map[string]interface{}{
            "content_type":  "reels",
            "share_to_feed": true,
            "first_comment": "Link in bio!",
        },
    }),
})

PostCreateResponse post = client.posts().create(PostCreateParams.builder()
    .content("New tutorial!")
    .addTarget("instagram")
    .addMedia(PostCreateParams.Media.builder()
        .url("https://cdn.example.com/reel.mp4")
        .type(PostCreateParams.Media.Type.VIDEO)
        .build())
    .scheduledAt("now")
    .targetOptions(PostCreateParams.TargetOptions.builder()
        .putAdditionalProperty("instagram", JsonValue.from(Map.of(
            "content_type", "reels",
            "share_to_feed", true,
            "first_comment", "Link in bio!"
        )))
        .build())
    .build());

curl -X POST https://api.relayapi.dev/v1/posts \
  -H "Authorization: Bearer $RELAY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "New tutorial!",
    "targets": ["instagram"],
    "media": [
      {"url": "https://cdn.example.com/reel.mp4", "type": "video"}
    ],
    "scheduled_at": "now",
    "target_options": {
      "instagram": {
        "content_type": "reels",
        "share_to_feed": true,
        "first_comment": "Link in bio!"
      }
    }
  }'

Post with Collaborators and User Tags

Tag collaborators (up to 3) and users in images. Collaborators receive an invite to co-author the post.

const post = await client.posts.create({
  content: 'Collab post with our partners!',
  targets: ['instagram'],
  media: [
    { url: 'https://cdn.example.com/photo.jpg', type: 'image' },
  ],
  scheduled_at: 'now',
  target_options: {
    instagram: {
      collaborators: ['brandpartner', 'creator123'],
      user_tags: [
        { username: 'friend', x: 0.5, y: 0.5 },
      ],
    },
  },
});

post = client.posts.create(
    content='Collab post with our partners!',
    targets=['instagram'],
    media=[
        {'url': 'https://cdn.example.com/photo.jpg', 'type': 'image'},
    ],
    scheduled_at='now',
    target_options={
        'instagram': {
            'collaborators': ['brandpartner', 'creator123'],
            'user_tags': [
                {'username': 'friend', 'x': 0.5, 'y': 0.5},
            ],
        },
    },
)

post, err := client.Posts.New(context.TODO(), relaygo.PostNewParams{
    Content:     relaygo.F("Collab post with our partners!"),
    Targets:     relaygo.F([]string{"instagram"}),
    ScheduledAt: relaygo.F("now"),
    Media: relaygo.F([]relaygo.PostNewParamsMedia{
        {URL: relaygo.F("https://cdn.example.com/photo.jpg"), Type: relaygo.F(relaygo.PostNewParamsMediaTypeImage)},
    }),
    TargetOptions: relaygo.F(map[string]interface{}{
        "instagram": map[string]interface{}{
            "collaborators": []string{"brandpartner", "creator123"},
            "user_tags": []map[string]interface{}{
                {"username": "friend", "x": 0.5, "y": 0.5},
            },
        },
    }),
})

PostCreateResponse post = client.posts().create(PostCreateParams.builder()
    .content("Collab post with our partners!")
    .addTarget("instagram")
    .addMedia(PostCreateParams.Media.builder()
        .url("https://cdn.example.com/photo.jpg")
        .type(PostCreateParams.Media.Type.IMAGE)
        .build())
    .scheduledAt("now")
    .targetOptions(PostCreateParams.TargetOptions.builder()
        .putAdditionalProperty("instagram", JsonValue.from(Map.of(
            "collaborators", List.of("brandpartner", "creator123"),
            "user_tags", List.of(Map.of(
                "username", "friend",
                "x", 0.5,
                "y", 0.5
            ))
        )))
        .build())
    .build());

curl -X POST https://api.relayapi.dev/v1/posts \
  -H "Authorization: Bearer $RELAY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Collab post with our partners!",
    "targets": ["instagram"],
    "media": [
      {"url": "https://cdn.example.com/photo.jpg", "type": "image"}
    ],
    "scheduled_at": "now",
    "target_options": {
      "instagram": {
        "collaborators": ["brandpartner", "creator123"],
        "user_tags": [
          {"username": "friend", "x": 0.5, "y": 0.5}
        ]
      }
    }
  }'

Post with First Comment

Automatically post a first comment after publishing. Useful for hashtag blocks or calls to action.

const post = await client.posts.create({
  content: 'New product launch!',
  targets: ['instagram'],
  media: [
    { url: 'https://cdn.example.com/product.jpg', type: 'image' },
  ],
  scheduled_at: 'now',
  target_options: {
    instagram: {
      first_comment: '#newproduct #launch #startup #tech #innovation',
    },
  },
});

post = client.posts.create(
    content='New product launch!',
    targets=['instagram'],
    media=[
        {'url': 'https://cdn.example.com/product.jpg', 'type': 'image'},
    ],
    scheduled_at='now',
    target_options={
        'instagram': {
            'first_comment': '#newproduct #launch #startup #tech #innovation',
        },
    },
)

post, err := client.Posts.New(context.TODO(), relaygo.PostNewParams{
    Content:     relaygo.F("New product launch!"),
    Targets:     relaygo.F([]string{"instagram"}),
    ScheduledAt: relaygo.F("now"),
    Media: relaygo.F([]relaygo.PostNewParamsMedia{
        {URL: relaygo.F("https://cdn.example.com/product.jpg"), Type: relaygo.F(relaygo.PostNewParamsMediaTypeImage)},
    }),
    TargetOptions: relaygo.F(map[string]interface{}{
        "instagram": map[string]interface{}{
            "first_comment": "#newproduct #launch #startup #tech #innovation",
        },
    }),
})

PostCreateResponse post = client.posts().create(PostCreateParams.builder()
    .content("New product launch!")
    .addTarget("instagram")
    .addMedia(PostCreateParams.Media.builder()
        .url("https://cdn.example.com/product.jpg")
        .type(PostCreateParams.Media.Type.IMAGE)
        .build())
    .scheduledAt("now")
    .targetOptions(PostCreateParams.TargetOptions.builder()
        .putAdditionalProperty("instagram", JsonValue.from(Map.of(
            "first_comment", "#newproduct #launch #startup #tech #innovation"
        )))
        .build())
    .build());

curl -X POST https://api.relayapi.dev/v1/posts \
  -H "Authorization: Bearer $RELAY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "New product launch!",
    "targets": ["instagram"],
    "media": [
      {"url": "https://cdn.example.com/product.jpg", "type": "image"}
    ],
    "scheduled_at": "now",
    "target_options": {
      "instagram": {
        "first_comment": "#newproduct #launch #startup #tech #innovation"
      }
    }
  }'

First comments work on feed posts and carousels only. They are not supported on stories or reels.

Media Requirements

Images

Property	Feed	Story	Carousel
Max images	1	1	10
Formats	JPEG, PNG	JPEG, PNG	JPEG, PNG
Max file size	8 MB	8 MB	8 MB each
Recommended	1080 x 1350 px	1080 x 1920 px	1080 x 1080 px

Aspect Ratios

Orientation	Ratio	Dimensions	Notes
Portrait	4:5	1080 x 1350 px	Best engagement for feed posts
Square	1:1	1080 x 1080 px	Standard feed and carousel
Landscape	1.91:1	1080 x 566 px	Widest allowed for feed
Vertical	9:16	1080 x 1920 px	Stories and Reels only

Feed posts accept aspect ratios between 4:5 (0.8) and 1.91:1. Outside that range, the content must be a Story or Reel.

Videos

Property	Feed	Reel	Story
Formats	MP4, MOV	MP4, MOV	MP4, MOV
Max size	300 MB	300 MB	100 MB
Max duration	60 min	90 sec	60 sec
Min duration	3 sec	3 sec	3 sec
Aspect ratio	4:5 to 1.91:1	9:16	9:16
Recommended	1080px wide	1080 x 1920 px	1080 x 1920 px
Codec	H.264	H.264	H.264

`target_options` Fields

All fields go inside target_options.instagram on your post request.

Field	Type	Description
`content`	string	Override caption for Instagram specifically
`media`	object[]	Override media for Instagram specifically
`content_type`	string	`"story"` or `"reels"` (default: feed post)
`share_to_feed`	boolean	Reels: also show on profile feed grid (default: true)
`collaborators`	string[]	Up to 3 usernames to invite as collaborators (feed and reels only)
`user_tags`	object[]	`{username, x, y, media_index?}` — tag users in images. Coordinates are 0-1 range.
`first_comment`	string	Auto-posted first comment (feed and carousels only)
`thumb_offset`	number	Millisecond offset for Reel cover thumbnail
`audio_name`	string	Custom audio name for Reels

Common Errors

Error	Cause	Fix
Cannot process video from URL	Cloud storage sharing link used (Drive, Dropbox)	Use a direct CDN URL that returns raw media bytes, not an HTML page
100 posts per day limit	Instagram hard 24-hour rolling limit reached	Reduce posting volume. This limit includes all content types.
Instagram blocked request	Automation detection triggered	Reduce frequency and vary content between posts
Duplicate content	Identical content posted recently	Modify caption or swap media files
Media fetch failed	Media URL is inaccessible or returns HTML	Verify URL returns actual media bytes with correct Content-Type header
Token expired	OAuth token expired or revoked	Reconnect the account via the dashboard or Connect API

Known Quirks

Media is required for all posts — Instagram does not support text-only posts.
Business or Creator account required — personal accounts cannot post via the API.
First 125 characters visible before the "more" fold. Front-load your most important message.
Google Drive, Dropbox, OneDrive URLs do not work — they return HTML download pages, not media bytes. Always use direct CDN URLs.
Stories do not display text captions — text is ignored. Link stickers are not available via the API.
Carousel first item determines aspect ratio for all subsequent items in the carousel.
Images over 8 MB are auto-compressed by Instagram, which may degrade quality.
100 posts per 24-hour rolling limit includes feed posts, carousels, stories, and reels combined.
User tags only work on images — not videos or stories. For carousels, use media_index to target specific slides.

Automations

The automations engine supports Instagram as a Tier 1 platform — both inbound conversational events (DMs, comments, mentions) and outbound send actions.

Triggers

Type	Fires on	Notes
`instagram_dm`	Inbound direct message	Requires Instagram Login app + Messaging API permission
`instagram_comment`	New comment on a post or reel	Payload includes `comment_id`, `post_id`, `parent_id`, `text`
`instagram_story_reply`	Reserved for story replies	Not runtime-supported yet
`instagram_story_mention`	Account @-mentioned in a story
`instagram_mention`	Account @-mentioned in post/comment
`instagram_reaction`	Message reaction added/removed
`instagram_live_comment`	Comment during a Live	Time-sensitive
`instagram_postback`	Structured button / ice-breaker postback
`instagram_referral`	User arrives via an IG Ref URL

Instagram does not expose a follower webhook via the public Graph API. The follow-to-dm template uses a manual trigger — you enroll new followers explicitly via the API or a separate polling job.

Send nodes

All Instagram send nodes hit https://graph.instagram.com/v25.0/{ig-user-id}/messages (or the associated comment endpoints). See the Instagram Messaging API.

Node	Purpose	Required fields
`instagram_send_text`	Plain text DM	`text` (supports merge tags)
`instagram_send_media`	Image / video / audio DM	`url`, `media_type` (default `image`)
`instagram_send_buttons`	Button template (≤3 buttons)	`text`, `buttons[]` with `type: postback
`instagram_send_quick_replies`	Text + quick-reply chips (≤13)	`text`, `quick_replies[]` with `title`, `payload?`
`instagram_send_generic_template`	Carousel of cards (≤10)	`elements[]` with `title`, optional `subtitle`, `image_url`, `buttons[]`
`instagram_typing`	Sender action	`off: boolean` — true sends `typing_off`, false sends `typing_on`
`instagram_mark_seen`	Sender action	—
`instagram_reply_to_comment`	Public comment reply	`text` (+ optional `comment_id`; defaults to the trigger's `comment_id`)
`instagram_hide_comment`	Hide a comment	`comment_id` (+ falls back to trigger's `comment_id`)

Quick example: comment → DM

await client.automations.templates.commentToDm({
  name: 'Spring launch comment → DM',
  account_id: 'acc_instagram_xyz',
  keywords: ['LINK', 'INFO'],
  match_mode: 'contains',
  dm_message: 'Hey {{first_name}}, here is the link you asked for: https://example.com/offer',
  public_reply: 'Check your DMs! 📨',
  once_per_user: true,
});

curl -X POST https://api.relayapi.dev/v1/automations/templates/comment-to-dm \
  -H "Authorization: Bearer $RELAY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Spring launch comment → DM",
    "account_id": "acc_instagram_xyz",
    "keywords": ["LINK", "INFO"],
    "dm_message": "Here is the link: https://example.com/offer",
    "public_reply": "Check your DMs!"
  }'

Rate limits + constraints

Messaging: Instagram enforces the 24-hour customer-service window. Inside 24h of the contact's last message you may DM freely; outside it, only HUMAN_AGENT-tagged messages are allowed (and those require a human-agent UX — not fully automated flows).
Comment reply cap: Graph API limits reply volume per post; avoid high-frequency reply bursts.
Token routing: Instagram Login tokens (IGAA prefix) route through graph.instagram.com; Facebook-auth legacy tokens use graph.facebook.com. The node handlers use graph.instagram.com by default — reconnect via Instagram Login if you hit a #100 scope error.

Found something wrong? Help us improve this page.

Report an issue Edit this page on GitHub