How to Automate Instagram Reels Scheduling using the API

Understanding the Instagram Graph API for Reels

Setting Up Instagram Graph API Authentication

The Instagram Graph API uses OAuth 2.0 long-lived User Access Tokens. Short-lived tokens last 1 hour and must be exchanged for 60-day long-lived tokens immediately after the OAuth flow. There is no automatic refresh — you must call the refresh endpoint before the 60-day expiry, but only after the token is at least 24 hours old.

1. 1Go to developers.facebook.com and create a new App (type: Business)
2. 2Add the Instagram product to your app from the App Dashboard
3. 3Under Instagram > API setup with Instagram Business Login, note your App ID and App Secret
4. 4Request instagram_business_basic and instagram_business_content_publish permissions via App Review > Permissions and Features
5. 5Implement the OAuth flow: redirect to https://www.facebook.com/v25.0/dialog/oauth?client_id={app-id}&redirect_uri={uri}&scope=instagram_business_basic,instagram_business_content_publish
6. 6Exchange the authorization code for a short-lived token at https://graph.facebook.com/v25.0/oauth/access_token
7. 7Exchange the short-lived token for a 60-day long-lived token: GET https://graph.instagram.com/access_token?grant_type=fb_exchange_token&client_id={app-id}&client_secret={app-secret}&fb_exchange_token={short-token}
8. 8Schedule a refresh job to call GET https://graph.instagram.com/refresh_access_token?grant_type=ig_refresh_token&access_token={token} every 50 days

1import requests
2import os
3
4APP_ID = os.environ['INSTAGRAM_APP_ID']
5APP_SECRET = os.environ['INSTAGRAM_APP_SECRET']
6
7def exchange_for_long_lived_token(short_lived_token):
8    resp = requests.get(
9        'https://graph.instagram.com/access_token',
10        params={
11            'grant_type': 'fb_exchange_token',
12            'client_id': APP_ID,
13            'client_secret': APP_SECRET,
14            'fb_exchange_token': short_lived_token,
15        }
16    )
17    resp.raise_for_status()
18    return resp.json()['access_token']
19
20def refresh_long_lived_token(long_lived_token):
21    resp = requests.get(
22        'https://graph.instagram.com/refresh_access_token',
23        params={
24            'grant_type': 'ig_refresh_token',
25            'access_token': long_lived_token,
26        }
27    )
28    resp.raise_for_status()
29    return resp.json()['access_token']
30
31def get_ig_user_id(access_token):
32    resp = requests.get(
33        'https://graph.instagram.com/v25.0/me',
34        params={'fields': 'id,username', 'access_token': access_token}
35    )
36    resp.raise_for_status()
37    return resp.json()['id']

Key endpoints

1{"media_type": "REELS", "video_url": "https://example.com/video.mp4", "caption": "Check this out #reels", "cover_url": "https://example.com/cover.jpg", "share_to_feed": true, "access_token": "EAAB..."}

1{"id": "17889615691580904"}

1{"status_code": "FINISHED", "id": "17889615691580904"}

1{"creation_id": "17889615691580904", "access_token": "EAAB..."}

1{"id": "17895695668004550"}

1{"data": [{"quota_usage": 3, "config": {"quota_total": 100, "quota_duration": 86400}}]}

Step-by-step automation

1# Check that the video URL is accessible before creating the container
2curl -I "https://example.com/video.mp4"

1curl -X POST \
2  "https://graph.instagram.com/v25.0/${IG_USER_ID}/media" \
3  -d "media_type=REELS" \
4  -d "video_url=https://example.com/reel.mp4" \
5  -d "cover_url=https://example.com/cover.jpg" \
6  -d "caption=Check this out %23reels" \
7  -d "share_to_feed=true" \
8  -d "access_token=${ACCESS_TOKEN}"

1# Poll until status_code is FINISHED
2while true; do
3  STATUS=$(curl -s "https://graph.instagram.com/v25.0/${CONTAINER_ID}?fields=status_code&access_token=${ACCESS_TOKEN}" | python3 -c "import sys,json; print(json.load(sys.stdin)['status_code'])")
4  echo "Status: $STATUS"
5  [ "$STATUS" = "FINISHED" ] && break
6  [ "$STATUS" = "ERROR" ] && echo "Processing failed" && exit 1
7  sleep 15
8done

1curl -X POST \
2  "https://graph.instagram.com/v25.0/${IG_USER_ID}/media_publish" \
3  -d "creation_id=${CONTAINER_ID}" \
4  -d "access_token=${ACCESS_TOKEN}"

Complete working code

This script implements a complete Reels scheduling pipeline: validates video format, checks publishing quota, creates the container, polls until FINISHED with appropriate backoff for video processing times, then publishes. Designed to run as a cron job or task queue worker.

1#!/usr/bin/env python3
2"""Instagram Reels Scheduler - cron job or queue worker."""
3import os
4import time
5import logging
6import requests
7
8logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
9log = logging.getLogger(__name__)
10
11IG_USER_ID = os.environ['IG_USER_ID']
12ACCESS_TOKEN = os.environ['IG_ACCESS_TOKEN']
13BASE = 'https://graph.instagram.com/v25.0'
14
15def api(method, path, **kwargs):
16    kwargs.setdefault('data', {})['access_token'] = ACCESS_TOKEN
17    kwargs.setdefault('params', {})['access_token'] = ACCESS_TOKEN
18    r = getattr(requests, method)(f'{BASE}{path}', timeout=30, **kwargs)
19    r.raise_for_status()
20    return r.json()
21
22def check_quota():
23    d = api('get', f'/{IG_USER_ID}/content_publishing_limit', params={'fields': 'config,quota_usage'})
24    item = d['data'][0]
25    log.info(f'Quota: {item["quota_usage"]}/{item["config"]["quota_total"]}')
26    return item['quota_usage'] < item['config']['quota_total']
27
28def create_reel_container(video_url, caption, cover_url=None):
29    body = {
30        'media_type': 'REELS',
31        'video_url': video_url,
32        'caption': caption,
33        'share_to_feed': 'true',
34    }
35    if cover_url:
36        body['cover_url'] = cover_url
37    return api('post', f'/{IG_USER_ID}/media', data=body)['id']
38
39def wait_until_ready(container_id, timeout=600):
40    deadline = time.time() + timeout
41    delay = 10
42    while time.time() < deadline:
43        status = api('get', f'/{container_id}', params={'fields': 'status_code'})['status_code']
44        log.info(f'Container {container_id}: {status}')
45        if status == 'FINISHED':
46            return
47        if status in ('ERROR', 'EXPIRED'):
48            raise ValueError(f'Container failed: {status}. Check H.264/AAC format and duration <=90s.')
49        delay = min(delay * 1.5, 60)
50        time.sleep(delay)
51    raise TimeoutError('Container processing timed out after 10 minutes')
52
53def publish(container_id):
54    return api('post', f'/{IG_USER_ID}/media_publish', data={'creation_id': container_id})['id']
55
56def schedule_reel(video_url, caption, cover_url=None):
57    if not check_quota():
58        log.warning('Daily publishing quota exhausted. Skipping.')
59        return None
60    log.info(f'Creating Reels container: {video_url}')
61    container_id = create_reel_container(video_url, caption, cover_url)
62    log.info(f'Waiting for video processing (container: {container_id})...')
63    wait_until_ready(container_id)
64    media_id = publish(container_id)
65    log.info(f'Reel published! Media ID: {media_id}')
66    return media_id
67
68if __name__ == '__main__':
69    media_id = schedule_reel(
70        video_url='https://your-cdn.com/reel.mp4',
71        caption='Your Reel caption here #reels',
72        cover_url='https://your-cdn.com/cover.jpg'
73    )
74    print(f'Published media_id: {media_id}')

Error handling

Rate Limits for Instagram Graph API (Reels)

1import time
2import requests
3
4def poll_with_backoff(container_id, access_token, max_polls=40, base_delay=10):
5    """Poll container status with exponential backoff. Safe within 200/hr limit."""
6    delay = base_delay
7    for i in range(max_polls):
8        resp = requests.get(
9            f'https://graph.instagram.com/v25.0/{container_id}',
10            params={'fields': 'status_code', 'access_token': access_token},
11            timeout=30
12        )
13        # Check rate limit headers
14        usage = resp.headers.get('X-Business-Use-Case-Usage', '{}')
15        if resp.status_code == 400 and resp.json().get('error', {}).get('code') == 17:
16            print(f'Rate limited. Waiting {delay * 4}s')
17            time.sleep(delay * 4)
18            continue
19        resp.raise_for_status()
20        status = resp.json()['status_code']
21        if status == 'FINISHED':
22            return True
23        if status in ('ERROR', 'EXPIRED'):
24            raise ValueError(f'Container failed: {status}')
25        delay = min(delay * 1.5, 60)  # Gentle growth, cap at 60s
26        time.sleep(delay)
27    raise TimeoutError('Max polls exceeded')

• Use a minimum 10-second polling interval for Reels (not 5 seconds like images) — video processing legitimately takes longer
• Implement a 10-minute hard timeout on polling — if video hasn't processed in 10 minutes, it likely has a format problem
• Monitor X-Business-Use-Case-Usage header and reduce poll frequency when call_count exceeds 60%
• Host videos on CDN storage (S3, Cloudflare R2) to ensure consistent download speeds for Instagram's processing servers
• Pre-validate video format with ffprobe before creating the container to avoid wasting calls on rejected videos

Security checklist

Automation use cases

No-code alternatives

Don't want to write code? These platforms can automate the same workflows visually.

Best practices

• Always pre-validate video with ffprobe before creating a container — H.264 codec and AAC audio are non-negotiable, and format errors return unhelpful error code 24
• Keep API-published Reels under 90 seconds — longer videos must be trimmed since the API hard-caps at 90s even though the native app supports 3+ minutes
• Use a cover_url thumbnail — Reels without a specified cover use the first frame, which is often a loading screen or awkward freeze frame
• Poll status with a minimum 10-second interval using exponential backoff — polling too fast burns your 200 calls/hour quota without speeding up processing
• Create containers only at publish time (2-5 minutes before target) — storing containers days ahead will result in expiry errors
• Implement idempotency: store container_id per scheduled Reel so a crashed worker doesn't create duplicate containers on restart
• Track the media_id of published Reels in your database to enable later analytics queries and content performance reporting

Ask AI to help

Copy one of these prompts to get a personalized, working implementation.

Related automations

Explore related guides

Guides from other topics that help with this issue