AccediInizia la prova gratuita
easyCoexistence API ufficiali

Pubblica su Instagram, TikTok e Facebook da Python con una sola API

Con easyCoexistence, il tuo codice Python pubblica su Instagram, Facebook, TikTok, YouTube e LinkedIn tramite l'API ufficiale di ogni rete. Ogni account accede una sola volta tramite un link ospitato; poi lo script recupera un token nuovo di TikTok, YouTube o LinkedIn con una sola GET, mentre le chiamate a Instagram e Facebook passano per gli strumenti MCP di easyCoexistence, che mantengono il token. Gli strumenti MCP danno a un agente Python gli stessi account.

1,000 bytes

Il testo più lungo che un solo DM su Instagram può contenere tramite l'API, conteggiato in UTF-8, quindi le emoji occupano più spazio.

24 hours

Quanto dura un token di accesso TikTok API for Business; il suo refresh token resta valido per un anno.

1 hour

Quanto dura un token di accesso utente Google, quello che ogni chiamata all'API di YouTube porta con sé.

OAuthClientProvider

L'handler OAuth dell'SDK Python di MCP, che registra il client, esegue l'accesso con PKCE e rinnova i token.

1 attempt

Gli eventi inoltrati di commenti, menzioni e DM vengono consegnati una sola volta e non vengono mai memorizzati, quindi confermali subito.

Come ottiene Python un token per Instagram, Facebook, TikTok, YouTube o LinkedIn?

Tramite una sessione di connessione sulla Partner API di easyCoexistence, autenticata con la tua chiave ec_live_. POST /connect-sessions con channel impostato su instagram, facebook, tiktok, youtube o linkedin restituisce un link ospitato per un cliente, valido per un'ora. Il cliente accede con il login della rete e arriva su redirect_url con status=connected e un channel_id, che il tuo backend conferma con GET /connect-sessions/{session} invece di fidarsi della query string. Il tuo codice non ha bisogno di una app di sviluppo propria su Meta, TikTok, Google o LinkedIn.

Poi chiedi le credenziali all'inizio di ogni esecuzione. GET /channels/{id}?credentials=1 restituisce la base dell'API della rete, l'id dell'account su quella rete e, per TikTok, YouTube e LinkedIn, un token di accesso che easyCoexistence mantiene rinnovato. Il token di TikTok dura 24 ore e quello di Google un'ora, quindi richiedilo a ogni esecuzione invece di salvarlo. I token di Instagram e Facebook non vengono mai consegnati; le loro chiamate passano dagli strumenti MCP.

Connect an account, then fetch its credentials per job
import os
import requests

EC = "https://easycoexistence.com/api/v1"
KEY = {"Authorization": f"Bearer {os.environ['EC_API_KEY']}"}  # ec_live_...

# A hosted sign-in link for one customer on one network
session = requests.post(f"{EC}/connect-sessions", headers=KEY, json={
    "channel": "instagram",  # or facebook, tiktok, youtube, linkedin
    "redirect_url": "https://app.example.com/connected",
    "external_ref": "customer_4821",
}).json()
print(session["url"])  # they come back with ?session=...&status=connected&channel_id=...

def credentials(channel_id: str) -> dict:
    """The network's API base and a token that is valid now. Call it per job."""
    r = requests.get(f"{EC}/channels/{channel_id}", headers=KEY, params={"credentials": 1})
    r.raise_for_status()
    creds = r.json()["credentials"]
    if not creds.get("access_token"):
        raise RuntimeError(creds.get("note", "This channel is not connected."))
    return creds

Come pubblichi su Instagram e Facebook da Python?

Instagram pubblica in due passaggi sulla Graph API di Meta, con il token come header bearer. POST /{ig-id}/media con image_url e caption crea un contenitore; quando un GET del suo status_code legge FINISHED, POST /{ig-id}/media_publish con il contenitore come creation_id lo mette sul profilo. Meta consiglia di controllare circa una volta al minuto, per un massimo di cinque minuti. Un Reel segue gli stessi passaggi, inviato con media_type REELS e un video_url al posto dell'immagine.

Un post sulla Pagina Facebook è una sola chiamata: POST /{page-id}/feed con un message e, se lo vuoi, un link. Aggiungendo published false e una scheduled_publish_time tra 10 minuti e 30 giorni da ora, Meta lo pubblica in quel momento, senza che nessun processo tuo sia in esecuzione. In entrambi i casi Meta scarica i media da un URL pubblico, e Instagram accetta solo immagini JPEG.

Publish a photo on Instagram and schedule a Page post
import time
import requests

def graph(c: dict, path: str, **body) -> dict:
    """Meta's Graph API: a POST when there is a body, a GET when there is none."""
    r = requests.request("POST" if body else "GET", f"{c['graph_api_base']}/{path}",
                         json=body or None, headers={"Authorization": f"Bearer {c['access_token']}"})
    r.raise_for_status()
    return r.json()

def post_to_instagram(channel_id: str, image_url: str, caption: str) -> str:
    c = credentials(channel_id)
    ig = c["account_id_on_meta"]
    container = graph(c, f"{ig}/media", image_url=image_url, caption=caption)["id"]
    for _ in range(5):  # Meta: check about once a minute, for up to five minutes
        status = graph(c, f"{container}?fields=status_code")["status_code"]
        if status == "FINISHED":
            return graph(c, f"{ig}/media_publish", creation_id=container)["id"]
        if status in ("ERROR", "EXPIRED"):
            raise RuntimeError(f"Instagram could not process the media: {status}")
        time.sleep(60)
    raise TimeoutError("The container is still processing")

def schedule_on_facebook(channel_id: str, message: str, publish_at: int) -> str:
    c = credentials(channel_id)
    post = graph(c, f"{c['account_id_on_meta']}/feed", message=message,
                 published=False, scheduled_publish_time=publish_at)  # unix seconds
    return post["id"]

Come carichi su YouTube e pubblichi su LinkedIn da Python?

YouTube accetta il video come upload riprendibile. La prima richiesta va all'endpoint di upload con uploadType=resumable e part=snippet,status e porta titolo e stato in JSON; l'header Location della risposta è l'indirizzo della sessione. Un PUT del file a quell'indirizzo risponde 201 con il nuovo video. Impostando privacyStatus su private con un orario publishAt, YouTube pubblica il video da solo in quel momento, e selfDeclaredMadeForKids indica se è destinato ai bambini.

LinkedIn richiede una sola POST a /rest/posts con il token bearer, un header LinkedIn-Version e X-Restli-Protocol-Version 2.0.0. Il corpo indica l'autore, porta il testo come commentary e imposta visibility, distribution e lifecycleState. Le credenziali forniscono author_urn, un urn:li:organization per una Pagina aziendale o un urn:li:person per un profilo, e la versione che easyCoexistence usa; l'URN del nuovo post torna nell'header x-restli-id.

Schedule a YouTube upload and publish a LinkedIn post
import requests

def schedule_on_youtube(channel_id: str, path: str, title: str, publish_at: str) -> str:
    c = credentials(channel_id)
    auth = {"Authorization": f"Bearer {c['access_token']}"}
    start = requests.post(
        "https://www.googleapis.com/upload/youtube/v3/videos",
        params={"uploadType": "resumable", "part": "snippet,status"},
        headers={**auth, "X-Upload-Content-Type": "video/mp4"},
        json={"snippet": {"title": title},
              "status": {"privacyStatus": "private", "publishAt": publish_at,  # ISO 8601
                         "selfDeclaredMadeForKids": False}},
    )
    start.raise_for_status()
    with open(path, "rb") as video:  # streamed, not read into memory
        done = requests.put(start.headers["Location"], data=video,
                            headers={**auth, "Content-Type": "video/mp4"})
    done.raise_for_status()
    return done.json()["id"]

def post_on_linkedin(channel_id: str, text: str) -> str:
    c = credentials(channel_id)
    r = requests.post(f"{c['api_base']}/posts", headers={
        "Authorization": f"Bearer {c['access_token']}",
        "LinkedIn-Version": c["required_headers"]["LinkedIn-Version"],  # YYYYMM
        "X-Restli-Protocol-Version": "2.0.0",
    }, json={
        "author": c["author_urn"],  # urn:li:organization:... or urn:li:person:...
        "commentary": text,
        "visibility": "PUBLIC",
        "distribution": {"feedDistribution": "MAIN_FEED", "targetEntities": [],
                         "thirdPartyDistributionChannels": []},
        "lifecycleState": "PUBLISHED",
        "isReshareDisabledByAuthor": False,
    })
    r.raise_for_status()
    return r.headers["x-restli-id"]  # the new post's URN

Come leggi e rispondi a commenti e DM in Python?

Attiva l'inoltro per il canale, verifica ogni consegna, poi rispondi tramite l'API della rete. PUT /channels/{id}/webhook con un url restituisce un signing_secret, mostrato una sola volta. Commenti, menzioni e DM su Instagram e Facebook, e commenti su TikTok, arrivano come POST con platform, account_id, external_id ed entry, con entry esattamente come l'ha inviato la rete. L'header X-EC-Signature riporta t=<unix>,v1=<hex>, e v1 è un HMAC-SHA256 del timestamp, di un punto e del corpo grezzo. Ogni evento viene inviato una volta, senza copia conservata e senza nuovi tentativi, quindi conferma per primo e lavora da una coda.

Una risposta a un DM di Instagram va a /{ig-id}/messages entro 24 ore dall'ultimo messaggio della persona, per al massimo 1.000 byte. Un commento riceve una risposta pubblica a /{comment-id}/replies, oppure una sola risposta privata entro 7 giorni. I commenti TikTok ricevono risposte pubbliche tramite business/comment/reply/create/, perché su TikTok non ci sono DM, mentre i commenti di YouTube e LinkedIn si leggono tramite le loro API a intervalli regolari.

Verify forwarded events and reply to Instagram DMs and comments
import hashlib, hmac, json, queue, time
import requests
from flask import Flask, abort, request

app = Flask(__name__)
jobs: queue.Queue = queue.Queue()  # a worker calls reply_on_instagram() for each event
SECRETS: dict[str, str] = {}  # channel_id -> signing_secret; keep them in your database

def forward_events(channel_id: str, url: str) -> None:
    r = requests.put(f"{EC}/channels/{channel_id}/webhook", headers=KEY, json={"url": url})
    r.raise_for_status()
    SECRETS[channel_id] = r.json()["signing_secret"]  # returned only this once

def verified(raw: bytes, header: str, secret: str) -> bool:
    parts = dict(p.split("=", 1) for p in header.split(",") if "=" in p)
    t, v1 = parts.get("t", ""), parts.get("v1", "")
    if not t.isdigit() or abs(time.time() - int(t)) > 300:
        return False
    mac = hmac.new(secret.encode(), t.encode() + b"." + raw, hashlib.sha256).hexdigest()
    return hmac.compare_digest(mac.encode(), v1.encode())

@app.post("/hooks/social")
def social_event():
    raw = request.get_data()
    event = json.loads(raw)  # platform, account_id, external_id, entry
    secret = SECRETS.get(event.get("account_id"))
    if not secret or not verified(raw, request.headers.get("X-EC-Signature", ""), secret):
        abort(401)
    jobs.put(event)  # sent once and never retried: acknowledge first, work after
    return "", 204

def reply_on_instagram(event: dict, text: str) -> None:
    c, me = credentials(event["account_id"]), event["external_id"]
    for m in event["entry"].get("messaging", []):  # DMs, minus echoes of your own
        if "message" in m and not m["message"].get("is_echo"):
            graph(c, f"{me}/messages", recipient={"id": m["sender"]["id"]}, message={"text": text})
    for ch in event["entry"].get("changes", []):  # comments, minus your own replies
        if ch["field"] == "comments" and ch["value"]["from"]["id"] != me:
            graph(c, f"{ch['value']['id']}/replies", message=text)

Come pubblichi su TikTok da Python?

Tramite lo strumento MCP publish_tiktok_post di easyCoexistence. L'API for Business di TikTok accetta un video come video_url e, dal 16 novembre 2023, lo scarica solo da un dominio o prefisso di URL verificato per l'app di sviluppo che sta dietro al token, quella di easyCoexistence. Lo strumento prende il tuo link HTTPS e consegna a TikTok un indirizzo firmato sulla route media verificata di easyCoexistence, trasmettendo il file senza memorizzarlo. I post con foto prendono invece image_urls, da 1 a 35 file JPEG o WebP, e get_tiktok_publish_status segue il post mentre TikTok lo elabora.

Da Python è una sola chiamata tramite l'SDK MCP ufficiale, versione 2, su Python 3.10 o successivo. Il server su https://easycoexistence.com/api/mcp accetta solo OAuth 2.1, quindi l'OAuthClientProvider dell'SDK registra il tuo client, esegue un solo accesso nel browser con PKCE e rinnova i token. I token di accesso durano un'ora e i refresh token 60 giorni, ogni rinnovo emette una nuova coppia, e uno storage che conserva questi token mantiene un backend connesso.

Publish a TikTok video through the MCP server
import asyncio
import os
from urllib.parse import parse_qs, urlparse

import httpx2
from pydantic import AnyUrl
from mcp import Client
from mcp.client.auth import AuthorizationCodeResult, OAuthClientProvider
from mcp.client.streamable_http import streamable_http_client
from mcp.shared.auth import OAuthClientInformationFull, OAuthClientMetadata, OAuthToken

MCP_URL = "https://easycoexistence.com/api/mcp"

class Storage:  # keep both values in a database, so the browser sign-in happens once
    tokens: OAuthToken | None = None
    client: OAuthClientInformationFull | None = None
    async def get_tokens(self): return self.tokens
    async def set_tokens(self, tokens): self.tokens = tokens
    async def get_client_info(self): return self.client
    async def set_client_info(self, info): self.client = info

async def show_sign_in(url: str) -> None:
    print("Sign in to easyCoexistence:", url)

async def read_callback() -> AuthorizationCodeResult:
    query = parse_qs(urlparse(input("Paste the address you were sent back to: ")).query)
    return AuthorizationCodeResult(code=query["code"][0], state=query["state"][0])

oauth = OAuthClientProvider(
    server_url=MCP_URL,
    client_metadata=OAuthClientMetadata(
        client_name="My social agent",
        redirect_uris=[AnyUrl("http://localhost:3030/callback")],
        scope="mcp",
    ),
    storage=Storage(),
    redirect_handler=show_sign_in,
    callback_handler=read_callback,
)

async def main() -> None:
    timeout = httpx2.Timeout(30.0, read=300.0)
    async with httpx2.AsyncClient(auth=oauth, timeout=timeout) as http:
        async with Client(streamable_http_client(MCP_URL, http_client=http)) as client:
            result = await client.call_tool("publish_tiktok_post", {
                "account_id": os.environ["TIKTOK_CHANNEL_ID"],  # the Partner API channel id
                "video_url": "https://cdn.example.com/launch.mp4",
                "caption": "New drop #behindthescenes",
            })
            print(result.content[0].text)  # a share_id for get_tiktok_publish_status

asyncio.run(main())

Come usa questi account un agente AI in Python?

Tramite la stessa sessione MCP. Il server elenca gli strumenti per le reti del tuo account, e qualsiasi framework di agenti che accetta strumenti MCP può passarli al proprio modello: pubblicare su ogni rete, elencare i post, leggere i commenti e rispondere, rispondere ai DM su Instagram e Facebook, impostare regole da commento a DM e leggere dati di insight e analytics. Le istruzioni del server e la descrizione di ogni strumento riportano le regole della rete, così il modello sa che le risposte su TikTok sono pubbliche e che le immagini Instagram devono essere JPEG.

Avvia l'agente con list_social_accounts, perché ogni altro strumento social prende un account_id da lì, e quell'id è lo stesso channel id restituito dalla Partner API. Le risposte che devono partire alle 3 di notte senza alcun agente in esecuzione appartengono alle regole sui commenti e alle automazioni, che girano su easyCoexistence stesso.

Errori comuni

  • Salvare il token in un file di configurazione. Quello di TikTok scade entro un giorno e quello di Google entro un'ora, e easyCoexistence li rinnova dietro le quinte, quindi chiama l'endpoint delle credenziali all'inizio di ogni esecuzione.
  • Dare a TikTok un link sul tuo dominio. TikTok scarica i media solo da prefissi di URL verificati per l'app che possiede il token, quindi pubblica tramite publish_tiktok_post, che serve il tuo file dall'indirizzo verificato di easyCoexistence.
  • Rispondere a ogni evento di commento, anche ai propri. Le tue risposte pubbliche tornano come nuovi commenti e i tuoi DM su Instagram come eco, quindi salta gli eventi il cui autore è l'account stesso, altrimenti il bot risponde a se stesso.
  • Misurare un DM di Instagram in caratteri. Il limite è di 1.000 byte UTF-8, quindi un testo con emoji o lettere accentate finisce prima; riduci il testo in base alla lunghezza codificata prima di inviarlo.
Farlo con EasyCoexistence

easyCoexistence dà al tuo codice Python e ai tuoi agenti AI accesso ai clienti su WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn e altri canali, tramite l'API ufficiale di ogni rete. La Partner API collega gli account e fornisce token nuovi, il server MCP dà agli agenti gli stessi account come strumenti, e ogni connessione è monitorata 24/7. Da US$ 9 a US$ 0,75 per connessione al mese, in calo con ogni connessione aggiunta, con i primi 3 giorni di prova gratuita.

Domande frequenti

Mi serve una mia app di sviluppo per Meta, TikTok, Google o LinkedIn?

No. Gli account accedono tramite l'app propria di easyCoexistence su ogni rete, e la chiamata alle credenziali fornisce al tuo codice il token di quell'account su TikTok, YouTube e LinkedIn, pronto all'uso con l'API della rete.

Quale versione di Python e quali librerie servono?

La Partner API e le API delle reti sono HTTPS semplice con JSON, quindi requests, httpx o qualsiasi altro client HTTP Python le chiama. L'SDK Python di MCP, versione 2, usato per la pubblicazione su TikTok e per gli strumenti degli agenti, richiede Python 3.10 o successivo.

Quali reti inviano commenti e DM al tuo endpoint?

Instagram e Facebook inoltrano commenti, menzioni e DM, e TikTok inoltra i commenti, ciascuno firmato con il segreto del canale. YouTube e LinkedIn non inviano questi eventi, quindi leggi i loro commenti tramite le API a intervalli regolari.

Quanto costa easyCoexistence per Python?

Da US$ 9 a US$ 0,75 per connessione al mese, in calo con ogni connessione aggiunta, uguale su ogni rete. La Partner API e il connettore MCP sono inclusi, senza licenze per utente, e i primi 3 giorni sono gratuiti.

Continua a leggere

Collega il tuo primo canale in due minuti.

Nessuna revisione delle piattaforme da aspettare. Collega WhatsApp, Instagram, TikTok o un altro canale, poi chiedi alla tua AI di pubblicare, rispondere o fare un report, e guardala al lavoro.

  • 3 giorni gratis
  • Disdici quando vuoi
  • Solo API ufficiali
  • Monitorato 24/7

Verificato il