Auto-Post Instagram Photos to Twitter/X with Native Image

Hey there, Darian Vance here. Let’s talk about a common time sink: social media cross-posting. For my personal brand and a few side projects, I was manually downloading photos from Instagram and re-uploading them to Twitter/X. It felt like digital busywork. After realizing I was burning a couple of hours every month on this, I built a simple Python script to automate it. Now, it just runs in the background, and I can focus on actual engineering. This is a real “work smarter, not harder” win.

This guide will walk you through setting up a Python script that automatically fetches your latest Instagram photo and posts it natively to your Twitter/X feed. Let’s get that time back.

Prerequisites

• Python 3.8 or newer installed.
• An Instagram Business or Creator account (required for API access).
• A Meta Developer App to get credentials for the Instagram Graph API.
• A Twitter/X Developer App with Elevated access to use the v2 API.
• The necessary API keys and access tokens from both platforms.

The Step-by-Step Guide

Step 1: Project Setup and Environment

First things first, set up your project directory. I’ll skip the standard virtualenv setup since you likely have your own workflow for that. The key is to create an isolated environment for our dependencies.

You’ll need to install three key Python libraries. You can do this with pip: describe installing `requests` for making HTTP calls, `python-dotenv` for managing our secret keys, and `tweepy` for interacting with the Twitter API.

In your project root, create a file named config.env. This is where we’ll store our API credentials instead of hardcoding them, which is a major security risk. Also, create an empty file named last_post.txt; we’ll use this to keep track of the last photo we posted to avoid duplicates.

Step 2: Storing Your API Credentials

Open up that config.env file and populate it with the keys you gathered from your Meta and Twitter/X developer dashboards. It should look something like this:

# Instagram Graph API
INSTAGRAM_USER_ID=YOUR_INSTAGRAM_BUSINESS_ACCOUNT_ID
INSTAGRAM_ACCESS_TOKEN=YOUR_LONG_LIVED_INSTAGRAM_ACCESS_TOKEN

# Twitter/X API v2
TWITTER_API_KEY=YOUR_TWITTER_API_KEY
TWITTER_API_SECRET_KEY=YOUR_TWITTER_API_SECRET
TWITTER_ACCESS_TOKEN=YOUR_TWITTER_ACCESS_TOKEN
TWITTER_ACCESS_TOKEN_SECRET=YOUR_TWITTER_ACCESS_TOKEN_SECRET

Pro Tip: Always add your config.env file to your .gitignore file. You never want to commit secrets to version control. In my production setups, I inject these as environment variables directly from a CI/CD pipeline or a secret manager like HashiCorp Vault.

Step 3: The Python Script Logic

Now for the core of the operation. Create a Python file, let’s call it ig_to_twitter.py. We’ll build this script in logical chunks.

A. Imports and Configuration

First, we import our libraries and load the environment variables from our config.env file.

import os
import requests
import tweepy
from dotenv import load_dotenv

# Load environment variables from config.env
load_dotenv('config.env')

# Instagram Config
IG_USER_ID = os.getenv('INSTAGRAM_USER_ID')
IG_ACCESS_TOKEN = os.getenv('INSTAGRAM_ACCESS_TOKEN')

# Twitter Config
TWITTER_API_KEY = os.getenv('TWITTER_API_KEY')
TWITTER_API_SECRET_KEY = os.getenv('TWITTER_API_SECRET_KEY')
TWITTER_ACCESS_TOKEN = os.getenv('TWITTER_ACCESS_TOKEN')
TWITTER_ACCESS_TOKEN_SECRET = os.getenv('TWITTER_ACCESS_TOKEN_SECRET')

LAST_POST_FILE = 'last_post.txt'

B. Fetching the Latest Instagram Post

This function queries the Instagram Graph API for the most recent media item. It checks against our last_post.txt file to see if we’ve already posted it. We’re only interested in single-image posts, so we’ll filter out videos and carousels.

def get_latest_instagram_post():
    """Fetches the latest single-image post from Instagram."""
    url = f"https://graph.facebook.com/v18.0/{IG_USER_ID}/media"
    params = {
        'fields': 'id,caption,media_type,media_url',
        'access_token': IG_ACCESS_TOKEN,
        'limit': 1 # We only need the very latest
    }
    response = requests.get(url, params=params)
    if response.status_code != 200:
        print(f"Error fetching from Instagram: {response.text}")
        return None

    data = response.json()['data']
    if not data:
        print("No media found on Instagram profile.")
        return None

    latest_post = data[0]

    # We only want to handle single images, not videos or carousels
    if latest_post.get('media_type') != 'IMAGE':
        print(f"Latest post is not an image (Type: {latest_post.get('media_type')}). Skipping.")
        return None

    # Check if we've already posted this
    try:
        with open(LAST_POST_FILE, 'r') as f:
            last_posted_id = f.read().strip()
        if latest_post['id'] == last_posted_id:
            print("No new post found. Exiting.")
            return None
    except FileNotFoundError:
        # If file doesn't exist, we'll create it later
        pass
        
    return latest_post

C. Posting to Twitter/X

This is a two-part process with the Twitter API. First, we download the image from the Instagram URL and upload it to Twitter’s media endpoint. This gives us a media_id. Second, we create the tweet, attaching that media_id so the image appears natively.

def post_to_twitter(post_data):
    """Downloads an image and posts it to Twitter with a caption."""
    try:
        # Authenticate with Tweepy
        client = tweepy.Client(
            consumer_key=TWITTER_API_KEY,
            consumer_secret=TWITTER_API_SECRET_KEY,
            access_token=TWITTER_ACCESS_TOKEN,
            access_token_secret=TWITTER_ACCESS_TOKEN_SECRET
        )
        auth = tweepy.OAuth1UserHandler(
            TWITTER_API_KEY, TWITTER_API_SECRET_KEY,
            TWITTER_ACCESS_TOKEN, TWITTER_ACCESS_TOKEN_SECRET
        )
        api_v1 = tweepy.API(auth)

        # 1. Download the image from Instagram's URL
        image_url = post_data['media_url']
        image_response = requests.get(image_url, stream=True)
        if image_response.status_code != 200:
            print("Failed to download image.")
            return

        # 2. Upload the image to Twitter to get a media_id
        # We need a temporary file to upload
        with open('temp_image.jpg', 'wb') as img_file:
            for chunk in image_response.iter_content(1024):
                img_file.write(chunk)
        
        media = api_v1.media_upload(filename='temp_image.jpg')
        media_id = media.media_id

        # 3. Create the tweet with the media_id
        caption = post_data.get('caption', 'New post from Instagram!')
        # Truncate caption for Twitter's limit
        tweet_text = (caption[:270] + '...') if len(caption) > 270 else caption
        
        client.create_tweet(text=tweet_text, media_ids=[media_id])
        print(f"Successfully posted Instagram post {post_data['id']} to Twitter.")
        
        # 4. Clean up and record success
        os.remove('temp_image.jpg')
        with open(LAST_POST_FILE, 'w') as f:
            f.write(post_data['id'])

    except Exception as e:
        print(f"An error occurred while posting to Twitter: {e}")

D. Main Execution Block

Finally, a simple main block to run our functions in order.

if __name__ == "__main__":
    print("Checking for new Instagram posts...")
    latest_post = get_latest_instagram_post()
    if latest_post:
        post_to_twitter(latest_post)
    else:
        print("Script finished. No new post to share.")

Step 4: Scheduling the Job with Cron

To make this truly automated, you need to run it on a schedule. On a Linux server, the classic tool for this is cron. You can set up a cron job to execute the script periodically.

For example, to run the script at the top of every hour, the cron entry would look like this:

0 * * * * python3 /path/to/your/project/ig_to_twitter.py

Here’s a breakdown of a different schedule, which runs at 2 AM on every Monday:

0 2 * * 1 python3 ig_to_twitter.py

Make sure to use the correct path to your Python interpreter and script. The frequency depends on how often you post. Hourly is usually fine and stays well within API rate limits.

Common Pitfalls (Where I Usually Mess Up)

• Expired Tokens: Instagram’s access tokens expire. For a robust, production-grade system, you need to implement the OAuth refresh token flow. For a personal script, you might just refresh it manually every 60 days.
• API Rate Limits: Don’t schedule your script to run every minute. It’s unnecessary and you’ll get rate-limited by the APIs. Once an hour is more than enough for most use cases.
• Forgetting to Update State: The biggest mistake I made early on was a bug where the script would fail to write the new ID to last_post.txt after a successful post. The next run, it would see the same “latest” post and tweet it again. Ensure your state-tracking is solid.
• Handling Non-Image Posts: This script explicitly skips videos and carousels. If you want to handle those, you’ll need to expand the logic. For carousels, you might post the first image or try to create a Twitter thread, which adds complexity.

Conclusion

And there you have it. A set-and-forget script that handles a tedious task for you, posting your Instagram content to Twitter/X with a native image. This small automation saves time and ensures your content gets consistent reach without manual intervention. It frees you up to focus on what matters.

Hope this helps you reclaim some time. Happy automating!

– Darian

---

🤖 Frequently Asked Questions