Se connecterCommencer l’essai gratuit
easyCoexistence API officielles

Publier sur Instagram, TikTok et Facebook depuis Python avec une seule API

Avec easyCoexistence, votre code Python publie sur Instagram, Facebook, TikTok, YouTube et LinkedIn via l'API officielle de chaque réseau. Chaque compte se connecte une seule fois via un lien hébergé ; votre script récupère ensuite un token frais TikTok, YouTube ou LinkedIn avec un seul GET, tandis que les appels Instagram et Facebook passent par les outils MCP d'easyCoexistence, qui conservent le token. Les outils MCP donnent à un agent Python les mêmes comptes.

1,000 bytes

La quantité maximale de texte qu'un DM Instagram peut contenir via l'API, comptée en UTF-8, donc les emoji occupent plus de place.

24 hours

La durée de validité d'un token d'accès de l'API for Business de TikTok ; son refresh token reste valide un an.

1 hour

La durée de validité d'un token d'accès utilisateur Google, celui que transporte chaque appel à l'API YouTube.

OAuthClientProvider

Le gestionnaire OAuth du SDK Python du MCP, qui enregistre le client, exécute la connexion avec PKCE et renouvelle les tokens.

1 attempt

Les événements de commentaire, de mention et de DM transmis sont livrés une seule fois et ne sont jamais conservés ; accusez réception de chacun immédiatement.

Comment Python obtient-il un token pour Instagram, Facebook, TikTok, YouTube ou LinkedIn ?

Par une session de connexion sur la Partner API d'easyCoexistence, authentifiée avec votre clé ec_live_. POST /connect-sessions avec channel défini sur instagram, facebook, tiktok, youtube ou linkedin renvoie un lien hébergé pour un client, valable une heure. Le client se connecte avec le login propre au réseau et arrive sur votre redirect_url avec status=connected et un channel_id, que votre backend confirme avec GET /connect-sessions/{session} plutôt que de faire confiance à la chaîne de requête. Votre code n'a jamais besoin de sa propre application développeur chez Meta, TikTok, Google ou LinkedIn.

Demandez ensuite les identifiants au début de chaque tâche. GET /channels/{id}?credentials=1 renvoie la base d'API du réseau, l'identifiant du compte sur ce réseau et, pour TikTok, YouTube et LinkedIn, un token d'accès qu'easyCoexistence maintient à jour. Le token de TikTok dure 24 heures et celui de Google une heure ; récupérez-le donc à chaque tâche au lieu de l'enregistrer. Les tokens Instagram et Facebook ne sont jamais remis ; leurs appels passent par les outils 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

Comment publier sur Instagram et Facebook depuis Python ?

Instagram publie en deux étapes sur la Graph API de Meta, avec le token dans l'en-tête bearer. POST /{ig-id}/media avec un image_url et une légende (caption) crée un conteneur ; une fois qu'un GET de son status_code affiche FINISHED, POST /{ig-id}/media_publish avec le conteneur comme creation_id le met sur le profil. Meta conseille de vérifier environ une fois par minute, pendant cinq minutes au maximum. Un Reel suit les mêmes étapes, envoyé avec media_type REELS et un video_url à la place d'une image.

Une publication sur une page Facebook est un seul appel : POST /{page-id}/feed avec un message et, si vous le souhaitez, un link. Ajouter published à false et un scheduled_publish_time situé entre 10 minutes et 30 jours à l'avance fait publier la publication par Meta à ce moment précis, sans qu'aucune tâche tourne de votre côté. Meta télécharge le média depuis une URL publique dans les deux cas, et Instagram n'accepte que les images 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"]

Comment envoyer une vidéo sur YouTube et publier sur LinkedIn depuis Python ?

YouTube reçoit la vidéo en envoi reprenable. La première requête part vers l'endpoint d'envoi avec uploadType=resumable et part=snippet,status, et transporte le titre et le statut en JSON ; l'en-tête Location de sa réponse est l'adresse de la session. Un PUT du fichier vers cette adresse répond 201 avec la nouvelle vidéo. Définir privacyStatus sur private avec une heure publishAt permet à YouTube de publier la vidéo seul à ce moment, et selfDeclaredMadeForKids indique si elle est destinée aux enfants.

LinkedIn reçoit un seul POST vers /rest/posts avec le token en bearer, un en-tête LinkedIn-Version et X-Restli-Protocol-Version 2.0.0. Le corps désigne l'auteur, porte le texte dans commentary et définit visibility, distribution et lifecycleState. Les identifiants fournissent author_urn, soit un urn:li:organization pour une page entreprise, soit un urn:li:person pour un profil, ainsi que la version utilisée par easyCoexistence ; l'URN de la nouvelle publication revient dans l'en-tête 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

Comment lire et répondre aux commentaires et aux DM en Python ?

Activez le transfert pour le canal, vérifiez chaque livraison, puis répondez via l'API du réseau. PUT /channels/{id}/webhook avec une url renvoie un signing_secret, affiché une seule fois. Les commentaires, mentions et DM sur Instagram et Facebook, ainsi que les commentaires sur TikTok, arrivent ensuite sous forme de POST avec platform, account_id, external_id et entry, entry étant exactement tel qu'envoyé par le réseau. L'en-tête X-EC-Signature se lit t=<unix>,v1=<hex>, et v1 est un HMAC-SHA256 de l'horodatage, d'un point et du corps brut. Chaque événement est envoyé une fois, sans copie conservée ni nouvelle tentative : accusez réception d'abord, puis traitez depuis une file d'attente.

Une réponse à un DM Instagram part vers /{ig-id}/messages dans les 24 heures suivant le dernier message de la personne, en 1 000 octets au maximum. Un commentaire reçoit une réponse publique sur /{comment-id}/replies, ou une seule réponse privée dans les 7 jours. Les commentaires TikTok reçoivent des réponses publiques via business/comment/reply/create/, car TikTok n'a pas de DM ; les commentaires YouTube et LinkedIn se lisent via leurs API selon un planning.

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)

Comment publier sur TikTok depuis Python ?

Par l'outil MCP publish_tiktok_post d'easyCoexistence. L'API for Business de TikTok reçoit une vidéo sous forme de video_url et, depuis le 16 novembre 2023, ne la télécharge que depuis un domaine ou un préfixe d'URL vérifié pour l'application développeur qui détient le token, celle d'easyCoexistence. L'outil prend votre lien HTTPS et remet à TikTok une adresse signée sur la route média vérifiée d'easyCoexistence, en diffusant le fichier sans le stocker. Les publications photo prennent à la place image_urls, de 1 à 35 fichiers JPEG ou WebP, et get_tiktok_publish_status suit la publication pendant que TikTok la traite.

Depuis Python, cela représente un seul appel via le SDK MCP officiel, version 2, sur Python 3.10 ou ultérieur. Le serveur à l'adresse https://easycoexistence.com/api/mcp n'accepte que OAuth 2.1 ; le OAuthClientProvider du SDK enregistre donc votre client, exécute une seule connexion dans le navigateur avec PKCE et renouvelle les tokens. Les tokens d'accès durent une heure et les refresh tokens 60 jours, chaque renouvellement émet une nouvelle paire, et un stockage persistant les conserve pour qu'un backend reste connecté.

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())

Comment un agent IA Python utilise-t-il ces comptes ?

Par la même session MCP. Le serveur liste les outils des réseaux de votre compte, et tout framework d'agent acceptant les outils MCP peut les transmettre à son modèle : publier sur chaque réseau, lister les publications, lire les commentaires et y répondre, répondre aux DM sur Instagram et Facebook, définir des règles de commentaire vers DM, et lire les statistiques et les analyses. Les instructions du serveur et la description de chaque outil portent les règles du réseau, de sorte que le modèle sache que les réponses TikTok sont publiques et que les images Instagram doivent être en JPEG.

Commencez l'agent avec list_social_accounts, car chaque autre outil social prend un account_id issu de cette liste, et cet identifiant est le même que le channel_id renvoyé par la Partner API. Les réponses qui doivent partir à 3 h du matin sans agent en marche relèvent des règles de commentaire et des automatisations, qui tournent sur easyCoexistence lui-même.

Erreurs courantes

  • Enregistrer le token dans un fichier de configuration. Celui de TikTok expire en moins d'un jour et celui de Google en moins d'une heure ; easyCoexistence les renouvelle en coulisses, donc appelez l'endpoint des identifiants au début de chaque tâche.
  • Donner à TikTok un lien sur votre propre domaine. TikTok ne télécharge les médias que depuis des préfixes d'URL vérifiés pour l'application qui détient le token ; publiez donc via publish_tiktok_post, qui sert votre fichier depuis l'adresse vérifiée d'easyCoexistence.
  • Répondre à chaque événement de commentaire, y compris les vôtres. Vos réponses publiques reviennent comme de nouveaux commentaires et vos DM Instagram comme des échos ; ignorez donc les événements dont l'auteur est le compte lui-même, sinon le bot se répond à lui-même.
  • Compter un DM Instagram en caractères. La limite est de 1 000 octets UTF-8, donc un texte avec des emoji ou des lettres accentuées atteint la limite plus vite ; raccourcissez selon la longueur encodée avant l'envoi.
Faire cela avec EasyCoexistence

easyCoexistence donne à votre code Python et à vos agents IA accès aux clients sur WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn et d'autres canaux, via l'API officielle de chaque réseau. La Partner API connecte les comptes et délivre des tokens à jour, le serveur MCP donne aux agents les mêmes comptes sous forme d'outils, et chaque connexion est surveillée 24/7. De US$ 9 à US$ 0,75 par connexion et par mois, dégressif à mesure que vous ajoutez des connexions, avec 3 jours d'essai gratuit.

Questions fréquemment posées

Ai-je besoin d'une application développeur propre chez Meta, TikTok, Google ou LinkedIn ?

Non. Les comptes se connectent via l'application propre d'easyCoexistence sur chaque réseau, et l'appel des identifiants remet à votre code le token de ce compte sur TikTok, YouTube et LinkedIn, prêt à être utilisé avec l'API du réseau.

Quelle version de Python et quelles bibliothèques faut-il ?

La Partner API et les API des réseaux sont du HTTPS simple avec du JSON ; requests, httpx ou tout autre client HTTP Python peut les appeler. Le SDK MCP Python, version 2, utilisé pour la publication TikTok et les outils d'agent, nécessite Python 3.10 ou ultérieur.

Quels réseaux envoient des commentaires et des DM à mon endpoint ?

Instagram et Facebook transmettent les commentaires, mentions et DM, et TikTok transmet les commentaires, chacun signé avec le secret du canal. YouTube et LinkedIn n'envoient aucun événement de ce type ; lisez donc leurs commentaires via leurs API selon un planning.

Combien coûte easyCoexistence pour Python ?

De US$ 9 à US$ 0,75 par connexion et par mois, dégressif à mesure que vous ajoutez des connexions, au même tarif sur chaque réseau. La Partner API et le connecteur MCP sont inclus, sans licence par utilisateur, avec 3 jours d'essai gratuit.

Poursuivre la lecture

Connectez votre premier canal en deux minutes.

Aucune validation de plateforme à attendre. Connectez WhatsApp, Instagram, TikTok ou un autre canal, puis demandez à votre IA de publier, de répondre ou de faire un rapport, et regardez-la travailler.

  • 3 jours gratuits
  • Résiliable à tout moment
  • API officielles uniquement
  • Supervisé 24/7

Vérifié le