How to Automate Instagram Post Scheduling using the API

Understanding the Instagram Graph API

Setting Up Instagram Graph API Authentication

The Instagram Graph API uses OAuth 2.0 with long-lived User Access Tokens. The short-lived token from the initial OAuth flow lasts only 1 hour — you must exchange it for a 60-day long-lived token immediately. There is no auto-refresh; you must call the refresh endpoint before 60 days expire, 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. 4In App Review > Permissions and Features, request instagram_business_basic and instagram_business_content_publish permissions
5. 5Implement the OAuth flow: redirect users to https://www.facebook.com/v25.0/dialog/oauth?client_id={app-id}&redirect_uri={redirect-uri}&scope=instagram_business_basic,instagram_business_content_publish
6. 6After the user authorizes, exchange 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 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-lived-token}
8. 8Store the long-lived token securely and schedule a refresh job to call GET https://graph.instagram.com/refresh_access_token?grant_type=ig_refresh_token&access_token={long-lived-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    """Exchange a short-lived token for a 60-day long-lived token."""
9    resp = requests.get(
10        'https://graph.instagram.com/access_token',
11        params={
12            'grant_type': 'fb_exchange_token',
13            'client_id': APP_ID,
14            'client_secret': APP_SECRET,
15            'fb_exchange_token': short_lived_token,
16        }
17    )
18    resp.raise_for_status()
19    data = resp.json()
20    return data['access_token']  # valid for 60 days
21
22def refresh_long_lived_token(long_lived_token):
23    """Refresh a long-lived token. Call this every 50 days."""
24    resp = requests.get(
25        'https://graph.instagram.com/refresh_access_token',
26        params={
27            'grant_type': 'ig_refresh_token',
28            'access_token': long_lived_token,
29        }
30    )
31    resp.raise_for_status()
32    return resp.json()['access_token']
33
34def get_ig_user_id(access_token):
35    """Get the Instagram user ID for the authenticated account."""
36    resp = requests.get(
37        'https://graph.instagram.com/v25.0/me',
38        params={'fields': 'id,username', 'access_token': access_token}
39    )
40    resp.raise_for_status()
41    return resp.json()['id']

Key endpoints

1{"image_url": "https://example.com/photo.jpg", "caption": "Beautiful sunset #nature", "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": 5, "config": {"quota_total": 100, "quota_duration": 86400}}]}

Step-by-step automation

1curl -s "https://graph.instagram.com/v25.0/${IG_USER_ID}/content_publishing_limit?fields=config,quota_usage&access_token=${ACCESS_TOKEN}"

1curl -X POST \
2  "https://graph.instagram.com/v25.0/${IG_USER_ID}/media" \
3  -d "image_url=https://example.com/photo.jpg" \
4  -d "caption=Beautiful sunset %23nature" \
5  -d "access_token=${ACCESS_TOKEN}"

1curl -s "https://graph.instagram.com/v25.0/${CONTAINER_ID}?fields=status_code&access_token=${ACCESS_TOKEN}"

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 complete script implements a full Instagram post scheduler. It reads a scheduled post from your database (or queue), checks the publishing quota, creates the media container at the scheduled time, polls for completion, then publishes. Designed to run as a cron job every minute.

1#!/usr/bin/env python3
2"""Instagram Post Scheduler - runs as a cron job every minute."""
3import os
4import time
5import logging
6import requests
7from datetime import datetime, timezone
8
9logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
10log = logging.getLogger(__name__)
11
12IG_USER_ID = os.environ['IG_USER_ID']
13ACCESS_TOKEN = os.environ['IG_ACCESS_TOKEN']
14BASE = 'https://graph.instagram.com/v25.0'
15
16def api_get(path, params):
17    params['access_token'] = ACCESS_TOKEN
18    r = requests.get(f'{BASE}{path}', params=params, timeout=30)
19    r.raise_for_status()
20    return r.json()
21
22def api_post(path, data):
23    data['access_token'] = ACCESS_TOKEN
24    r = requests.post(f'{BASE}{path}', data=data, timeout=30)
25    r.raise_for_status()
26    return r.json()
27
28def check_quota():
29    data = api_get(f'/{IG_USER_ID}/content_publishing_limit', {'fields': 'config,quota_usage'})
30    item = data['data'][0]
31    used = item['quota_usage']
32    total = item['config']['quota_total']
33    log.info(f'Quota: {used}/{total}')
34    return used < total
35
36def create_container(image_url, caption):
37    result = api_post(f'/{IG_USER_ID}/media', {'image_url': image_url, 'caption': caption})
38    return result['id']
39
40def wait_for_ready(container_id, max_wait=120):
41    deadline = time.time() + max_wait
42    delay = 5
43    while time.time() < deadline:
44        result = api_get(f'/{container_id}', {'fields': 'status_code'})
45        status = result['status_code']
46        log.info(f'Container {container_id}: {status}')
47        if status == 'FINISHED':
48            return True
49        if status in ('ERROR', 'EXPIRED'):
50            raise ValueError(f'Container failed with status: {status}')
51        time.sleep(delay)
52        delay = min(delay * 2, 30)
53    raise TimeoutError('Container processing timed out')
54
55def publish(container_id):
56    result = api_post(f'/{IG_USER_ID}/media_publish', {'creation_id': container_id})
57    return result['id']
58
59def schedule_post(image_url, caption):
60    """Full scheduling flow: check quota, create, wait, publish."""
61    if not check_quota():
62        log.warning('Daily quota exhausted. Skipping.')
63        return None
64    log.info(f'Creating container for: {image_url}')
65    container_id = create_container(image_url, caption)
66    log.info(f'Waiting for container {container_id} to finish processing...')
67    wait_for_ready(container_id)
68    media_id = publish(container_id)
69    log.info(f'Post published successfully. Media ID: {media_id}')
70    return media_id
71
72if __name__ == '__main__':
73    # In production, fetch this from your scheduler DB
74    media_id = schedule_post(
75        image_url='https://example.com/photo.jpg',
76        caption='Your caption here #hashtag'
77    )
78    print(f'Done: {media_id}')

Error handling

Rate Limits for Instagram Graph API

1import time
2import requests
3
4def api_request_with_retry(method, url, max_retries=5, **kwargs):
5    for attempt in range(max_retries):
6        resp = getattr(requests, method)(url, **kwargs, timeout=30)
7        if resp.status_code == 429 or resp.status_code == 400:
8            data = resp.json()
9            code = data.get('error', {}).get('code')
10            if code in (17, 4, 32):  # Rate limit codes
11                wait = min(60 * (2 ** attempt), 3600)
12                print(f'Rate limited. Waiting {wait}s (attempt {attempt+1})')
13                time.sleep(wait)
14                continue
15        return resp
16    raise Exception('Max retries exceeded')

• Check X-Business-Use-Case-Usage response header — it returns JSON with call_count, total_cputime, total_time as percentages; alert when any exceeds 80%
• Cache GET responses (media metadata, insights) for at least 1 hour to avoid redundant reads eating your 200 calls/hour quota
• Batch your analytics queries: fetch the top 10 most recent posts and their insights in two calls rather than one call per post
• Create containers only at publish time (not days ahead) since they expire in 24 hours — this lets you concentrate your API calls around actual publish windows
• Monitor the content_publishing_limit endpoint daily to proactively manage the 100 posts/day cap across multiple accounts

Security checklist

Automation use cases

No-code alternatives

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

Best practices

• Never create media containers more than a few minutes before the target publish time — containers expire after 24 hours, and storing containers wastes quota
• Always validate image aspect ratio (4:5 to 1.91:1) and format (JPEG only) before calling the API to avoid wasted container creation calls
• Implement idempotency in your scheduler: store container_id and media_id per post so failed runs don't create duplicate containers
• Monitor the X-Business-Use-Case-Usage header on every response and pause non-urgent operations when any metric exceeds 80%
• Use the content_publishing_limit endpoint at the start of each scheduling run, not just when you expect to hit the cap
• Log both the container creation time and publish time for every post — this helps debug expiry issues and quota calculations
• For bulk posting (campaigns, product launches), spread posts across multiple hours rather than posting at once — the 100/day cap resets as a sliding window

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