Tech With Galvan
Back to Articles
AutomationAug 17, 2029 • 4 min read

How to Auto-Post New Blog Articles to Social Media

Automatically share new blog posts to social media — RSS triggers, Zapier, Make, and Python. Never manually share again.

Galvan
Galvan

Founder & Creator

Introduction

You just published a blog post. Now you need to share it on Twitter, LinkedIn, Facebook, and Instagram. Manually crafting posts for each platform takes 30-60 minutes. Auto-posting does it in seconds: new blog post → formatted social posts → published everywhere.

This post shows you 3 ways to automate blog-to-social sharing.

Method 1: Zapier (no-code, easiest)

Setup

  1. Create a Zapier account (free tier: 100 tasks/month)
  2. Trigger: RSS by Zapier → New Item in Feed
  3. Actions: Multiple (one per platform)

Zapier workflow

Trigger: New item in RSS feed (https://yoursite.com/rss.xml)
    ↓
Action 1: Twitter → Create Tweet
    Text: "New post: {title}\n\n{link}\n\n{description}"
    ↓
Action 2: LinkedIn → Create Share
    Text: "I just published: {title}\n\n{description}\n\nRead more: {link}"
    ↓
Action 3: Facebook → Create Page Post
    Message: "{title}\n\n{description}\n\n{link}"
    ↓
Action 4: Buffer → Add to Queue (for Instagram)

Pros: No code, easy setup, multi-platform

Cons: Free tier limited (100 tasks/month), less control over formatting

Method 2: Make (Integromat) (more flexible)

Setup

  1. Create a Make account (free tier: 1,000 operations/month)
  2. Trigger: RSS → Watch RSS Feed
  3. Actions: HTTP requests to each platform’s API

Make workflow

Trigger: Watch RSS feed
    ↓
Action 1: HTTP → POST to Twitter API
    ↓
Action 2: HTTP → POST to LinkedIn API
    ↓
Action 3: HTTP → POST to Facebook API
    ↓
Action 4: HTTP → POST to Buffer API (for Instagram)

Pros: More flexible, more free operations, conditional logic

Cons: More complex setup

Method 3: Python (full control)

import feedparser, requests, os
from datetime import datetime

RSS_URL = "https://yoursite.com/rss.xml"
TWITTER_BEARER = os.environ["TWITTER_BEARER"]
LINKEDIN_TOKEN = os.environ["LINKEDIN_TOKEN"]

def fetch_latest_posts(count=1):
    """Fetch latest posts from RSS feed."""
    feed = feedparser.parse(RSS_URL)
    posts = []
    for entry in feed.entries[:count]:
        posts.append({
            "title": entry.title,
            "link": entry.link,
            "summary": entry.summary[:200] if hasattr(entry, "summary") else "",
            "published": entry.published,
        })
    return posts

def post_to_twitter(post):
    """Post to Twitter/X."""
    import tweepy
    client = tweepy.Client(bearer_token=TWITTER_BEARER)
    text = f"New post: {post['title']}\n\n{post['summary'][:100]}...\n\n{post['link']}"
    response = client.create_tweet(text=text)
    print(f"Posted to Twitter: {post['title']}")
    return response

def post_to_linkedin(post):
    """Post to LinkedIn."""
    url = "https://api.linkedin.com/v2/ugcPosts"
    headers = {"Authorization": f"Bearer {LINKEDIN_TOKEN}", "Content-Type": "application/json"}
    payload = {
        "author": f"urn:li:person:YOUR_PERSON_ID",
        "lifecycleState": "PUBLISHED",
        "specificContent": {
            "com.linkedin.ugc.ShareContent": {
                "shareCommentary": {"text": f"I just published: {post['title']}\n\n{post['summary'][:200]}\n\nRead more: {post['link']}"},
                "shareMediaCategory": "NONE",
            }
        },
        "visibility": {"com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC"},
    }
    r = requests.post(url, json=payload, headers=headers)
    print(f"Posted to LinkedIn: {post['title']}")
    return r.status_code == 201

def post_to_facebook(post):
    """Post to Facebook Page."""
    page_id = os.environ["FB_PAGE_ID"]
    token = os.environ["FB_PAGE_TOKEN"]
    url = f"https://graph.facebook.com/v18.0/{page_id}/feed"
    payload = {"message": f"{post['title']}\n\n{post['summary'][:200]}\n\n{post['link']}", "access_token": token}
    r = requests.post(url, data=payload)
    print(f"Posted to Facebook: {post['title']}")
    return r.status_code == 200

def main():
    posts = fetch_latest_posts(1)
    for post in posts:
        post_to_twitter(post)
        post_to_linkedin(post)
        post_to_facebook(post)
        print(f"Shared: {post['title']}")

if __name__ == "__main__":
    main()

Step 4: Automate with cron

# Check for new posts and share daily at 9 AM
0 9 * * * cd /path/to/project && python auto_share.py

Or use GitHub Actions:

name: Share New Posts
on:
  schedule:
    - cron: '0 9 * * *'
jobs:
  share:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: pip install feedparser tweepy requests
      - run: python auto_share.py

Step 5: Track what’s been shared

Avoid sharing the same post twice:

import json, os

SHARED_FILE = "shared_posts.json"

def load_shared():
    if os.path.exists(SHARED_FILE):
        return json.load(open(SHARED_FILE))
    return []

def save_shared(shared):
    json.dump(shared, open(SHARED_FILE, "w"), indent=2)

def main():
    shared = load_shared()
    posts = fetch_latest_posts(5)
    
    for post in posts:
        if post["link"] in shared:
            continue  # Already shared
        
        post_to_twitter(post)
        post_to_linkedin(post)
        post_to_facebook(post)
        
        shared.append(post["link"])
        save_shared(shared)
        print(f"Shared: {post['title']}")

Best practices

  1. Don’t share immediately — wait 1-2 hours after publishing (lets you catch typos)
  2. Customize per platform — Twitter = short + hashtags, LinkedIn = professional + insight, Facebook = casual
  3. Include an image — posts with images get 2x more engagement
  4. Don’t over-share — 1-2 posts per day max per platform
  5. Track performance — which platform drives the most traffic?

Common mistakes

  • Sharing the same text everywhere — each platform has different norms and character limits
  • No image — text-only posts get ignored
  • Sharing too fast — publish, wait, then share (catches typos)
  • No tracking — you don’t know which platform works best
  • Spamming — sharing the same post 5 times in a week annoys followers

Key Concepts

  • RSS feed = XML file with your latest posts
  • Webhook = HTTP callback for real-time events
  • UTM parameters = tracking tags for analytics
  • Cross-posting = sharing the same content across platforms
  • Content calendar = planned posts with dates and platforms

What to Try Next

FAQ

Zapier vs Make vs Python — which to use?

Zapier = easiest, no code. Make = more flexible, more free operations. Python = full control, free, but requires hosting. Start with Zapier; move to Python when you need custom logic.

Can I auto-post to Instagram?

Instagram doesn’t allow direct API posting (except via Meta Business Suite). Use Buffer or Later for Instagram scheduling. Or use Instagram’s native scheduling (available for business accounts).

How do I avoid duplicate posts?

Track shared posts in a JSON file or database. Check before sharing. The script above handles this automatically.

Should I auto-post or schedule manually?

Auto-post for consistency (never miss a share). But review the first 3-5 auto-posts to ensure formatting is correct. Once you’re confident, let it run. See Repurpose Blog Posts with AI. See Schedule Social Media Posts.