Mit einer API aus Python auf Instagram, TikTok und Facebook posten
Mit easyCoexistence postet Python-Code über die offiziellen APIs der jeweiligen Netzwerke auf Instagram, Facebook, TikTok, YouTube und LinkedIn. Jedes Konto meldet sich einmal über einen gehosteten Link an. Danach holt Ihr Skript mit einem einzigen GET ein frisches TikTok-, YouTube- oder LinkedIn-Token, während Instagram- und Facebook-Aufrufe über die MCP-Tools von easyCoexistence laufen, die das Token verwalten. Die MCP-Tools geben einem Python-Agenten dieselben Konten.
Die maximale Textlänge einer Instagram-DM über die API, in UTF-8 gezählt; Emojis benötigen mehr Platz.
Wie lange ein Zugriffstoken der TikTok API for Business gültig ist; sein Refresh-Token bleibt ein Jahr gültig.
Wie lange ein Google-Benutzer-Zugriffstoken gültig ist, also das Token, das jeder YouTube-API-Aufruf mitführt.
Der OAuth-Handler des MCP Python SDK, der den Client registriert, die Anmeldung mit PKCE durchführt und Token erneuert.
Weitergeleitete Kommentar-, Erwähnungs- und DM-Ereignisse werden einmal zugestellt und nie gespeichert; bestätigen Sie daher jedes sofort.
Wie holt sich Python ein Token für Instagram, Facebook, TikTok, YouTube oder LinkedIn?
Über eine Connect-Session der Partner API von easyCoexistence, authentifiziert mit Ihrem ec_live_-Schlüssel. POST /connect-sessions mit channel auf instagram, facebook, tiktok, youtube oder linkedin liefert einen gehosteten Link für einen Kunden, eine Stunde gültig. Der Kunde meldet sich mit dem eigenen Login des Netzwerks an und landet auf Ihrer redirect_url mit status=connected und einer channel_id. Ihr Backend bestätigt diese mit GET /connect-sessions/{session}, statt dem Query-String zu vertrauen. Ihr Code braucht keine eigene Entwickler-App bei Meta, TikTok, Google oder LinkedIn.
Fordern Sie die Zugangsdaten dann zu Beginn jedes Auftrags an. GET /channels/{id}?credentials=1 liefert die API-Basis des Netzwerks, die ID des Kontos in diesem Netzwerk und bei TikTok, YouTube und LinkedIn ein Zugriffstoken, das easyCoexistence laufend erneuert. Das TikTok-Token gilt 24 Stunden und das Google-Token eine Stunde. Holen Sie es deshalb pro Auftrag, statt es zu speichern. Instagram- und Facebook-Token werden nie herausgegeben; deren Aufrufe laufen über die MCP-Tools.
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 credsWie veröffentlichen Sie aus Python auf Instagram und Facebook?
Instagram veröffentlicht in zwei Schritten über die Graph API von Meta, mit dem Token als Bearer-Header. POST /{ig-id}/media mit image_url und caption erstellt einen Container. Sobald ein GET von dessen status_code FINISHED anzeigt, setzt POST /{ig-id}/media_publish mit dem Container als creation_id den Beitrag auf das Profil. Meta empfiehlt, etwa einmal pro Minute zu prüfen, bis zu fünf Minuten lang. Ein Reel folgt denselben Schritten, gesendet mit media_type REELS und einer video_url statt eines Bildes.
Ein Beitrag auf einer Facebook-Seite ist ein einziger Aufruf: POST /{page-id}/feed mit message und, falls gewünscht, einem link. Wenn Sie published false und eine scheduled_publish_time zwischen 10 Minuten und 30 Tagen in der Zukunft angeben, veröffentlicht Meta den Beitrag genau dann, ohne dass ein Auftrag Ihrerseits läuft. Meta lädt Medien in beiden Fällen von einer öffentlichen URL herunter, und Instagram akzeptiert nur JPEG-Bilder.
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"]Wie laden Sie aus Python auf YouTube hoch und posten auf LinkedIn?
YouTube nimmt das Video als wiederaufnehmbaren Upload entgegen. Die erste Anfrage geht an den Upload-Endpoint mit uploadType=resumable und part=snippet,status und trägt Titel und Status als JSON; der Location-Header der Antwort ist die Sitzungsadresse. Ein PUT der Datei an diese Adresse antwortet mit 201 und dem neuen Video. Wenn Sie privacyStatus auf private und eine publishAt-Zeit setzen, veröffentlicht YouTube das Video selbstständig zu diesem Zeitpunkt. selfDeclaredMadeForKids legt fest, ob es für Kinder bestimmt ist.
LinkedIn nimmt einen einzigen POST an /rest/posts mit dem Bearer-Token, einem LinkedIn-Version-Header und X-Restli-Protocol-Version 2.0.0 entgegen. Der Body nennt den Autor, trägt den Text als commentary und setzt visibility, distribution und lifecycleState. Die Zugangsdaten liefern author_urn, also eine urn:li:organization für eine Unternehmensseite oder eine urn:li:person für ein Profil, sowie die Version, die easyCoexistence verwendet. Die URN des neuen Beitrags kommt im Header x-restli-id zurück.
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 URNWie lesen und beantworten Sie Kommentare und DMs in Python?
Aktivieren Sie die Weiterleitung für den Kanal, prüfen Sie jede Zustellung und antworten Sie dann über die API des Netzwerks. PUT /channels/{id}/webhook mit einer url liefert ein signing_secret, das nur einmal angezeigt wird. Kommentare, Erwähnungen und DMs auf Instagram und Facebook sowie Kommentare auf TikTok treffen dann als POST mit platform, account_id, external_id und entry ein, wobei entry exakt so enthalten ist, wie das Netzwerk es gesendet hat. Der Header X-EC-Signature lautet t=<unix>,v1=<hex>; v1 ist ein HMAC-SHA256 aus dem Zeitstempel, einem Punkt und dem rohen Body. Jedes Ereignis wird einmal gesendet, ohne Kopie und ohne Wiederholung. Bestätigen Sie daher zuerst und arbeiten Sie aus einer Warteschlange.
Eine Antwort auf eine Instagram-DM geht an /{ig-id}/messages innerhalb von 24 Stunden nach der letzten Nachricht der Person, mit höchstens 1,000 Bytes. Ein Kommentar erhält eine öffentliche Antwort unter /{comment-id}/replies oder eine einzige private Antwort innerhalb von 7 Tagen. TikTok-Kommentare erhalten öffentliche Antworten über business/comment/reply/create/, da es auf TikTok keine DMs gibt. YouTube- und LinkedIn-Kommentare lesen Sie nach einem Zeitplan über deren APIs.
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)Wie posten Sie aus Python auf TikTok?
Über das MCP-Tool publish_tiktok_post von easyCoexistence. Die API for Business von TikTok nimmt ein Video als video_url entgegen und lädt es seit dem 16. November 2023 nur noch von einer Domain oder einem URL-Präfix herunter, das für die Entwickler-App hinter dem Token verifiziert ist, also für die App von easyCoexistence. Das Tool nimmt Ihren HTTPS-Link entgegen und übergibt TikTok eine signierte Adresse auf der verifizierten Medienroute von easyCoexistence, die die Datei streamt, ohne sie zu speichern. Fotobeiträge nehmen stattdessen image_urls entgegen, 1 bis 35 JPEG- oder WebP-Dateien, und get_tiktok_publish_status verfolgt den Beitrag, während TikTok ihn verarbeitet.
Aus Python ist das ein Aufruf über das offizielle MCP SDK, Version 2, ab Python 3.10. Der Server unter https://easycoexistence.com/api/mcp akzeptiert nur OAuth 2.1. Daher registriert der OAuthClientProvider des SDK Ihren Client, führt eine einzige Anmeldung im Browser mit PKCE durch und erneuert die Token. Zugriffstoken gelten eine Stunde, Refresh-Token 60 Tage. Jede Erneuerung stellt ein neues Paar aus, und ein Speicher, der sie dauerhaft hält, hält ein Backend angemeldet.
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())Wie nutzt ein Python-KI-Agent diese Konten?
Über dieselbe MCP-Sitzung. Der Server listet die Tools für die Netzwerke Ihres Kontos auf, und jedes Agenten-Framework, das MCP-Tools akzeptiert, kann sie seinem Modell übergeben: auf jedem Netzwerk veröffentlichen, Beiträge auflisten, Kommentare lesen und beantworten, DMs auf Instagram und Facebook beantworten, Regeln für Kommentar-zu-DM festlegen sowie Insights und Analysen abrufen. Die Anweisungen des Servers und die Beschreibung jedes Tools enthalten die Regeln des jeweiligen Netzwerks, sodass das Modell lernt, dass TikTok-Antworten öffentlich sind und Instagram-Bilder JPEG sein müssen.
Starten Sie den Agenten mit list_social_accounts, denn jedes andere Social-Tool nimmt daraus eine account_id entgegen, und diese ID ist dieselbe Kanal-ID, die die Partner API zurückgibt. Antworten, die um 3 Uhr nachts ohne laufenden Agenten rausgehen müssen, gehören zu Kommentarregeln und Automatisierungen, die auf easyCoexistence selbst laufen.
Häufige Fehler
- Das Token in einer Konfigurationsdatei speichern. Das TikTok-Token läuft innerhalb eines Tages ab, das Google-Token innerhalb einer Stunde, und easyCoexistence erneuert sie im Hintergrund. Rufen Sie deshalb den Credentials-Endpoint zu Beginn jedes Auftrags auf.
- TikTok einen Link auf Ihrer eigenen Domain geben. TikTok lädt Medien nur von URL-Präfixen herunter, die für die App verifiziert sind, die das Token hält. Veröffentlichen Sie deshalb über publish_tiktok_post, das Ihre Datei von der verifizierten Adresse von easyCoexistence ausliefert.
- Auf jedes Kommentarereignis antworten, auch auf Ihr eigenes. Ihre öffentlichen Antworten kommen als neue Kommentare zurück und Ihre Instagram-DMs als Echos. Überspringen Sie daher Ereignisse, deren Autor das Konto selbst ist, sonst antwortet sich der Bot selbst.
- Eine Instagram-DM in Zeichen messen. Die Grenze liegt bei 1,000 Bytes UTF-8, daher erreicht Text mit Emojis oder Akzentbuchstaben das Limit schneller. Kürzen Sie nach der kodierten Länge, bevor Sie senden.
Mit easyCoexistence erhalten Ihr Python-Code und Ihre KI-Agenten Zugang zu Kunden auf WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn und weiteren Kanälen, über die offiziellen APIs der jeweiligen Netzwerke. Die Partner API verbindet Konten und stellt frische Token aus, der MCP-Server gibt Agenten dieselben Konten als Tools, und jede Verbindung wird rund um die Uhr überwacht. US$ 9 bis US$ 0.75 pro Verbindung und Monat, mit jeder weiteren Verbindung sinkend, mit den ersten 3 Tagen kostenlos.
Häufig gestellte Fragen
Brauchen Sie eine eigene Entwickler-App bei Meta, TikTok, Google oder LinkedIn?
Nein. Konten melden sich über die eigene App von easyCoexistence bei jedem Netzwerk an. Der Aufruf der Zugangsdaten liefert Ihrem Code das Token dieses Kontos bei TikTok, YouTube und LinkedIn, das sofort gegen die API des Netzwerks verwendet werden kann.
Welche Python-Version und welche Bibliotheken brauche ich?
Die Partner API und die APIs der Netzwerke sind einfaches HTTPS mit JSON, daher rufen requests, httpx oder jeder andere Python-HTTP-Client sie auf. Das MCP Python SDK, Version 2, das für die TikTok-Veröffentlichung und Agenten-Tools verwendet wird, benötigt Python 3.10 oder neuer.
Welche Netzwerke senden Kommentare und DMs an meinen Endpoint?
Instagram und Facebook leiten Kommentare, Erwähnungen und DMs weiter, TikTok leitet Kommentare weiter, jeweils signiert mit dem Geheimnis des Kanals. YouTube und LinkedIn senden keine solchen Ereignisse. Lesen Sie deren Kommentare daher nach einem Zeitplan über deren APIs.
Was kostet easyCoexistence für Python?
US$ 9 bis US$ 0.75 pro Verbindung und Monat, mit jeder weiteren Verbindung sinkend und auf jedem Netzwerk gleich. Die Partner API und der MCP-Connector sind inklusive, ohne Nutzerplätze, und die ersten 3 Tage sind kostenlos.
Weiterlesen
Verbinden Sie Ihren ersten Kanal in zwei Minuten.
Keine Plattform-Prüfungen, auf die Sie warten müssen. Verbinden Sie WhatsApp, Instagram, TikTok oder einen anderen Kanal, bitten Sie dann Ihre KI, zu posten, zu antworten oder Berichte zu erstellen, und sehen Sie ihr bei der Arbeit zu.
- 3 Tage kostenlos
- Jederzeit kündbar
- Nur offizielle APIs
- Überwacht rund um die Uhr (24/7)
Verifiziert am