Perché Python per l\'automazione dei social media

Python e il linguaggio di riferimento per l\'automazione. E leggibile, ha un ecosistema enorme ed e perfetto per script che girano a intervalli regolari. E quando si tratta di pubblicare sui social media in modo programmatico, l\'alternativa all\'uso di un\'API come Upload-Post e costruire integrazioni OAuth per ogni piattaforma. Questo significa gestire la Content Posting API di TikTok, la Graph API di Instagram, la Data API di YouTube e cosi via. Ognuna con il suo flusso di autenticazione, i suoi limiti di rate e le sue particolarita.

Con l'API di pubblicazione sui social media, fai una singola chiamata API e pubblichi su tutte e dieci le piattaforme. L\'SDK Python rende tutto ancora piu semplice.

Configurare l\'ambiente

1. Installa l\'SDK

pip install upload-post

2. Ottieni la tua API key

Crea un account gratuito su app.upload-post.com e genera una API key dalla dashboard API Keys. Salvala come variabile d\'ambiente:

export UPLOAD_POST_API_KEY="your-api-key-here"

3. Collega i tuoi account social

Nella dashboard di Upload-Post, crea un profilo (es. "mybrand") e collega i tuoi account TikTok, Instagram, YouTube e qualsiasi altro account su cui vuoi pubblicare. Il nome del profilo e quello che userai nel tuo codice.

Il tuo primo upload: pubblicare un video

import os
from upload_post import UploadPostClient

client = UploadPostClient(
    api_key=os.environ["UPLOAD_POST_API_KEY"]
)

response = client.upload_video(
    video_path="my-video.mp4",
    title="Il nostro nuovo prodotto in azione",
    user="mybrand",
    platforms=["tiktok", "instagram", "youtube"]
)

if response["success"]:
    for platform, result in response["results"].items():
        if result["success"]:
            print(f"{platform}: {result['url']}")
        else:
            print(f"{platform}: upload failed")
else:
    print("Upload failed:", response)

Questo e uno script funzionante. Eseguilo e il tuo video va live su tre piattaforme. Ora facciamolo fare di piu.

Publish photos and carousels

response = client.upload_photos(
    photos=["slide-1.jpg", "slide-2.jpg", "slide-3.jpg"],
    title="Lookbook della collezione estiva",
    description="Ogni pezzo, realizzato in Portogallo. Acquista il link in bio.",
    user="mybrand",
    platforms=["instagram", "tiktok", "linkedin"]
)

print(response)

Instagram crea un post carosello, TikTok crea uno slideshow e LinkedIn mostra un post multi-immagine. Ogni piattaforma riceve il formato che preferisce.

Publish text content

Per post solo testo (pensa ai thread su Twitter, aggiornamenti LinkedIn o post su Reddit):

response = client.upload_text(
    title="Abbiamo appena rilasciato un enorme aggiornamento alla nostra API. Ecco cosa è cambiato...",
    user="mybrand",
    platforms=["x", "linkedin", "threads", "bluesky"]
)

print(response)

Se il tuo testo supera il limite di caratteri di una piattaforma, l\'API lo gestisce in modo intelligente. Su X, il testo oltre i 280 caratteri diventa automaticamente un thread. Su Threads, la suddivisione avviene a 500 caratteri. Su Bluesky, a 300.

Usare parametri specifici per piattaforma

Il parametro title imposta la didascalia predefinita per tutte le piattaforme, ma spesso vorrai testi diversi per ciascuna. Ecco come personalizzare per piattaforma:

import requests
import os

API_KEY = os.environ["UPLOAD_POST_API_KEY"]

with open("product-demo.mp4", "rb") as video:
    response = requests.post(
        "https://api.upload-post.com/api/upload",
        headers={"Autorizzazione": f"Apikey {API_KEY}"},
        files={"video": video},
        data={
            "user": "mybrand",
            "title": "Check this out",
            # Platform specific titles
            "tiktok_title": "POV: il tuo prodotto si vende da solo #ecommerce #dropshipping",
            "instagram_title": "Nuovo rilascio. Link in bio per accesso anticipato.",
            "youtube_title": "Demo del prodotto | Recensione completa",
            "youtube_description": "In questo video ti mostriamo esattamente come funziona...",
            "linkedin_title": "Siamo entusiasti di condividere il nostro ultimo lancio di prodotto con la comunità.",
            # Platform specific settings
            "platform[]": ["tiktok", "instagram", "youtube", "linkedin"],
            "privacy_level": "PUBLIC_TO_EVERYONE",
            "media_type": "REELS",
            "tags[]": ["product", "demo", "review"],
            "privacyStatus": "public",
        }
    )

print(response.json())

Questo esempio usa la libreria requests direttamente invece dell\'SDK, il che ti da accesso a ogni singolo parametro API. Consulta il riferimento API completo per tutte le opzioni disponibili per piattaforma.

Schedule posts for later

from datetime import datetime, timedelta

# Schedule for tomorrow at 9 AM
tomorrow_9am = (datetime.now() + timedelta(days=1)).replace(
    hour=9, minute=0, second=0, microsecond=0
)

response = client.upload_video(
    video_path="tomorrows-content.mp4",
    title="Buongiorno! Contenuti freschi per il tuo feed",
    user="mybrand",
    platforms=["tiktok", "instagram"],
    scheduled_date=tomorrow_9am.isoformat(),
    timezone="America/New_York"
)

print(f"Scheduled! Job ID: {response['job_id']}")
print(f"Pubblicherà alle: {response['scheduled_date']}")

Puoi programmare fino a 365 giorni in anticipo. Per maggiori dettagli sulla programmazione e il sistema di code, leggi la nostra guida alla programmazione.

Costruire un\'automazione completa: watcher di cartella

Ecco uno script pratico che monitora una cartella alla ricerca di nuovi file video e li carica automaticamente. Ottimo per agenzie che ricevono contenuti dei clienti in una cartella condivisa:

import os
import time
import json
from upload_post import UploadPostClient

client = UploadPostClient(
    api_key=os.environ["UPLOAD_POST_API_KEY"]
)

WATCH_FOLDER = "/path/to/content/inbox"
PROCESSED_FILE = "/path/to/content/processed.json"
CHECK_INTERVAL = 60  # seconds

def load_processed():
    if os.path.exists(PROCESSED_FILE):
        with open(PROCESSED_FILE) as f:
            return set(json.load(f))
    return set()

def save_processed(processed):
    with open(PROCESSED_FILE, "w") as f:
        json.dump(list(processed), f)

def upload_video(filepath):
    filename = os.path.basename(filepath)
    title = filename.rsplit(".", 1)[0].replace("-", " ").replace("_", " ")

    response = client.upload_video(
        video_path=filepath,
        title=title,
        user="mybrand",
        platforms=["tiktok", "instagram", "youtube"],
        add_to_queue=True,
        async_upload=True
    )
    return response

print(f"Watching {WATCH_FOLDER} for new videos...")

processed = load_processed()

while True:
    for filename in os.listdir(WATCH_FOLDER):
        if filename in processed:
            continue
        if not filename.lower().endswith((".mp4", ".mov")):
            continue

        filepath = os.path.join(WATCH_FOLDER, filename)
        print(f"New file detected: {filename}")

        try:
            result = upload_video(filepath)
            print(f"  Queued successfully: {result.get('job_id', 'done')}")
            processed.add(filename)
            save_processed(processed)
        except Exception as e:
            print(f"  Error: {e}")

    time.sleep(CHECK_INTERVAL)

Esegui questo script in background (o come servizio systemd) e ogni volta che qualcuno mette un video nella cartella, viene pubblicato su tutte le piattaforme collegate. Se hai bisogno di qualcosa di piu robusto, considera l\'uso di n8n o Make.com per un workflow gestito.

Lavorare con l\'API direttamente (senza l\'SDK)

Se preferisci non usare l\'SDK o hai bisogno di un controllo piu granulare, puoi usare la libreria requests direttamente. Ecco l\'equivalente dell\'upload con l\'SDK:

import requests

API_KEY = "your-api-key-here"
API_URL = "https://api.upload-post.com/api/upload"

# Upload a video
with open("video.mp4", "rb") as f:
    response = requests.post(
        API_URL,
        headers={"Autorizzazione": f"Apikey {API_KEY}"},
        files={"video": ("video.mp4", f, "video/mp4")},
        data={
            "user": "mybrand",
            "title": "Pubblicato con richieste Python",
            "platform[]": ["tiktok", "instagram"],
        }
    )

print(response.status_code)
print(response.json())

Validare la tua API key

Prima di eseguire un batch consistente, e una buona idea verificare che la tua chiave funzioni e controllare i limiti del tuo piano:

response = requests.get(
    "https://api.upload-post.com/api/uploadposts/me",
    headers={"Autorizzazione": f"Apikey {API_KEY}"}
)

data = response.json()
print(f"Email: {data['email']}")
print(f"Piano: {data['plan']}")

Migliori pratiche per la gestione degli errori

Quando costruisci script per la produzione, gestisci questi scenari comuni:

import requests

def upload_with_retry(video_path, title, platforms, max_retries=3):
    for attempt in range(max_retries):
        try:
            with open(video_path, "rb") as f:
                response = requests.post(
                    "https://api.upload-post.com/api/upload",
                    headers={"Autorizzazione": f"Apikey {API_KEY}"},
                    files={"video": f},
                    data={
                        "user": "mybrand",
                        "title": title,
                        "platform[]": platforms,
                        "async_upload": "true",
                    },
                    timeout=120
                )

            if response.status_code == 200:
                return response.json()
            elif response.status_code == 429:
                # Rate limited, check usage
                usage = response.json().get("usage", {})
                print(f"Rate limited. Used {usage.get('count')}/{usage.get('limit')}")
                return None
            elif response.status_code == 401:
                print("Invalid API key")
                return None
            else:
                print(f"Attempt {attempt + 1} failed: {response.status_code}")

        except requests.exceptions.Timeout:
            print(f"Attempt {attempt + 1} timed out, retrying...")

    print(f"Tutti i {max_retries} tentativi sono falliti per {video_path}")
    return None

Controllare lo storico degli upload

Puoi recuperare lo storico degli upload per verificare cosa e andato a buon fine o costruire una dashboard di reportistica:

response = requests.get(
    "https://api.upload-post.com/api/uploadposts/history?page=1&limit=20",
    headers={"Autorizzazione": f"Apikey {API_KEY}"}
)

for entry in response.json()["history"]:
    status = "OK" if entry["success"] else "FAILED"
    print(f"[{status}] {entry['platform']} - {entry['post_title']} - {entry['post_url']}")

Next steps

Ora che hai le basi, ecco alcune idee su cosa costruire dopo:

Collega il tuo script a un CMS o database in modo che i nuovi contenuti vengano pubblicati automaticamente
Usa l\'approccio di upload massivo per elaborare intere librerie di contenuti
Riutilizza video lunghi in clip brevi usando FFmpeg e l\'API di Upload-Post
Costruisci un\'integrazione white label se stai costruendo un prodotto SaaS che necessita di pubblicazione social
Esplora i nostri template n8n per workflow potenziati dall\'AI che generano e pubblicano contenuti automaticamente

Come Automatizzare la Pubblicazione sui Social Media con Python