InloggenGratis proefperiode starten
easyCoexistence Officiële API's

Posten op Instagram, TikTok en Facebook vanuit Python met één API

Met easyCoexistence publiceert je Python-code posts op Instagram, Facebook, TikTok, YouTube en LinkedIn via de officiële API van elk netwerk. Elk account meldt zich één keer aan via een gehoste link. Daarna haalt je script met één GET een vers TikTok-, YouTube- of LinkedIn-token op, terwijl Instagram- en Facebook-aanroepen via de MCP-tools van easyCoexistence gaan, die het token bijhouden. De MCP-tools geven een Python-agent dezelfde accounts.

1,000 bytes

Het meeste tekst dat één Instagram-DM via de API kan bevatten, geteld in UTF-8, dus emoji nemen meer ruimte in.

24 hours

Hoe lang een toegangstoken van de TikTok API for Business geldig blijft; het refresh-token blijft een jaar geldig.

1 hour

Hoe lang een Google-toegangstoken voor gebruikers geldig blijft, het soort dat elke YouTube API-aanroep meestuurt.

OAuthClientProvider

De OAuth-handler van de MCP Python SDK, die de client registreert, de aanmelding met PKCE uitvoert en tokens vernieuwt.

1 attempt

Doorgestuurde reactie-, vermeldings- en DM-gebeurtenissen worden één keer afgeleverd en nooit opgeslagen, dus bevestig elk direct.

Hoe krijgt Python een token voor Instagram, Facebook, TikTok, YouTube of LinkedIn?

Via een connect-sessie op de Partner API van easyCoexistence, geauthenticeerd met je ec_live_-sleutel. POST /connect-sessions met channel ingesteld op instagram, facebook, tiktok, youtube of linkedin geeft een gehoste link voor één klant, één uur geldig. Die meldt zich aan met de eigen login van het netwerk en komt terecht op je redirect_url met status=connected en een channel_id. Je backend bevestigt dat met GET /connect-sessions/{session} in plaats van de querystring te vertrouwen. Je code heeft nooit een eigen developer-app nodig bij Meta, TikTok, Google of LinkedIn.

Vraag daarna bij elke taak opnieuw de inloggegevens op. GET /channels/{id}?credentials=1 geeft de API-basis van het netwerk, het id van het account op dat netwerk en, bij TikTok, YouTube en LinkedIn, een toegangstoken dat easyCoexistence actueel houdt. Het TikTok-token is 24 uur geldig en dat van Google één uur, dus haal het per taak op in plaats van het op te slaan. Instagram- en Facebook-tokens worden nooit uitgegeven; de aanroepen daarvoor gaan via de MCP-tools.

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

Hoe plaats je posts op Instagram en Facebook vanuit Python?

Instagram publiceert in twee stappen via de Graph API van Meta, met het token als bearer-header. POST /{ig-id}/media met een image_url en een bijschrift maakt een container aan. Zodra een GET van de status_code FINISHED aangeeft, zet POST /{ig-id}/media_publish met de container als creation_id de post op het profiel. Meta adviseert ongeveer elke minuut te controleren, maximaal vijf minuten. Een Reel verloopt op dezelfde manier, verstuurd met media_type REELS en een video_url in plaats van een afbeelding.

Een Facebook-pagina-post is één aanroep: POST /{page-id}/feed met een message en, als je wilt, een link. Met published false en een scheduled_publish_time tussen 10 minuten en 30 dagen vooruit publiceert Meta de post op dat moment, zonder dat een taak van jou draait. Meta haalt media in beide gevallen op via een publieke URL, en Instagram accepteert alleen JPEG-afbeeldingen.

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"]

Hoe upload je naar YouTube en plaats je een post op LinkedIn vanuit Python?

YouTube neemt de video op als hervatbare upload. Het eerste verzoek gaat naar het upload-endpoint met uploadType=resumable en part=snippet,status, en draagt de titel en status als JSON. De Location-header van het antwoord is het sessieadres. Een PUT van het bestand naar dat adres geeft 201 terug met de nieuwe video. Door privacyStatus op private te zetten met een publishAt-tijd publiceert YouTube de video op dat moment zelf, en selfDeclaredMadeForKids legt vast of hij voor kinderen is gemaakt.

LinkedIn vraagt één POST naar /rest/posts met het bearer-token, een LinkedIn-Version-header en X-Restli-Protocol-Version 2.0.0. De body noemt de auteur, bevat de tekst als commentary en zet visibility, distribution en lifecycleState. De inloggegevens leveren author_urn, een urn:li:organization voor een bedrijfspagina of een urn:li:person voor een profiel, en de versie die easyCoexistence gebruikt. De URN van de nieuwe post komt terug in de x-restli-id-header.

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

Hoe lees en beantwoord je reacties en DM's in Python?

Zet doorsturen voor het kanaal aan, verifieer elke aflevering en antwoord daarna via de API van het netwerk. PUT /channels/{id}/webhook met een url geeft een signing_secret terug, die maar één keer wordt getoond. Reacties, vermeldingen en DM's op Instagram en Facebook, en reacties op TikTok, komen daarna binnen als een POST met platform, account_id, external_id en entry, waarbij entry exact is zoals het netwerk die verstuurde. De header X-EC-Signature heeft de vorm t=<unix>,v1=<hex>, waarbij v1 een HMAC-SHA256 is van de tijdstempel, een punt en de ruwe body. Elk event wordt één keer verstuurd, zonder kopie en zonder nieuwe poging, dus bevestig eerst en werk vanuit een wachtrij.

Een antwoord op een Instagram-DM gaat naar /{ig-id}/messages binnen 24 uur na het laatste bericht van de persoon, in maximaal 1.000 bytes. Een reactie krijgt een publiek antwoord op /{comment-id}/replies, of één privé-antwoord binnen 7 dagen. TikTok-reacties krijgen publieke antwoorden via business/comment/reply/create/, omdat TikTok geen DM's heeft. YouTube- en LinkedIn-reacties lees je volgens een schema via hun API's.

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)

Hoe plaats je posts op TikTok vanuit Python?

Via de MCP-tool publish_tiktok_post van easyCoexistence. De API for Business van TikTok neemt een video als video_url en downloadt die sinds 16 november 2023 alleen van een domein of URL-prefix dat geverifieerd is voor de developer-app achter het token. Die app is van easyCoexistence. De tool neemt je HTTPS-link en geeft TikTok een ondertekend adres op de geverifieerde media-route van easyCoexistence, waarbij het bestand wordt gestreamd zonder het op te slaan. Fotoposts gebruiken in plaats daarvan image_urls, 1 tot 35 JPEG- of WebP-bestanden, en get_tiktok_publish_status volgt de post terwijl TikTok hem verwerkt.

Vanuit Python is dat één aanroep via de officiële MCP SDK, versie 2, op Python 3.10 of nieuwer. De server op https://easycoexistence.com/api/mcp accepteert alleen OAuth 2.1, dus de OAuthClientProvider van de SDK registreert je client, voert één aanmelding in de browser uit met PKCE en vernieuwt tokens. Toegangstokens zijn één uur geldig en refresh-tokens 60 dagen. Elke vernieuwing geeft een nieuw paar uit, en opslag die ze bewaart houdt een backend ingelogd.

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

Hoe gebruikt een Python-AI-agent deze accounts?

Via dezelfde MCP-sessie. De server somt de tools op voor de netwerken op je account, en elk agent-framework dat MCP-tools accepteert kan ze aan zijn model geven: publiceren op elk netwerk, posts weergeven, reacties lezen en erop antwoorden, antwoorden op DM's op Instagram en Facebook, regels voor reactie-naar-DM instellen, en inzichten en analyses lezen. De instructies van de server en de beschrijving van elke tool bevatten de regels van het netwerk, zodat het model leert dat antwoorden op TikTok publiek zijn en dat Instagram-afbeeldingen JPEG moeten zijn.

Start de agent met list_social_accounts, want elke andere social-tool neemt een account_id daaruit over. Dat id is hetzelfde kanaal-id dat de Partner API teruggeeft. Antwoorden die om 3 uur 's nachts moeten uitgaan zonder dat een agent draait, horen bij reactieregels en automatiseringen, die op easyCoexistence zelf draaien.

Veelgemaakte fouten

  • Het token in een configuratiebestand opslaan. Het TikTok-token verloopt binnen een dag en dat van Google binnen een uur. easyCoexistence vernieuwt ze op de achtergrond, dus roep het inloggegevens-endpoint aan aan het begin van elke taak.
  • Aan TikTok een link op je eigen domein geven. TikTok downloadt media alleen van URL-prefixen die geverifieerd zijn voor de app die het token bezit. Publiceer dus via publish_tiktok_post, die je bestand serveert vanaf het geverifieerde adres van easyCoexistence.
  • Op elk reactie-event antwoorden, ook op je eigen reacties. Je publieke antwoorden komen terug als nieuwe reacties en je Instagram-DM's als echo's. Sla events over waarvan de auteur het account zelf is, anders antwoordt de bot op zichzelf.
  • Een Instagram-DM in tekens meten. Het maximum is 1.000 bytes UTF-8, dus tekst met emoji of accenten raakt sneller op. Kort in op basis van de gecodeerde lengte voordat je verstuurt.
Dit doen met EasyCoexistence

easyCoexistence geeft je Python-code en je AI-agenten bereik tot klanten op WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn en meer kanalen, via de officiële API van elk netwerk. De Partner API koppelt accounts en levert verse tokens, de MCP-server geeft agenten dezelfde accounts als tools, en elke verbinding wordt 24/7 bewaakt. US$ 9 tot US$ 0,75 per verbinding per maand, dalend naarmate je meer verbindingen toevoegt, waarvan de eerste 3 dagen gratis zijn.

Veelgestelde vragen

Heb ik een eigen developer-app nodig bij Meta, TikTok, Google of LinkedIn?

Nee. Accounts melden zich aan via de eigen app van easyCoexistence bij elk netwerk. De aanroep voor inloggegevens geeft je code het token van dat account op TikTok, YouTube en LinkedIn, klaar voor gebruik tegen de API van het netwerk.

Welke Python-versie en bibliotheken heb ik nodig?

De Partner API en de API's van de netwerken zijn gewone HTTPS met JSON, dus requests, httpx of een andere Python HTTP-client roept ze aan. De MCP Python SDK, versie 2, die TikTok-publiceren en agent-tools gebruiken, vereist Python 3.10 of nieuwer.

Welke netwerken sturen reacties en DM's naar mijn endpoint?

Instagram en Facebook sturen reacties, vermeldingen en DM's door, en TikTok stuurt reacties door, elk ondertekend met het ondertekeningsgeheim van het kanaal. YouTube en LinkedIn sturen geen zulke events, dus lees hun reacties volgens een schema via hun API's.

Wat kost easyCoexistence voor Python?

US$ 9 tot US$ 0,75 per verbinding per maand, dalend naarmate je meer verbindingen toevoegt, op elk netwerk hetzelfde. De Partner API en de MCP-connector zijn inbegrepen, zonder zetels, en de eerste 3 dagen zijn gratis.

Lees verder

Koppel je eerste kanaal in twee minuten.

Geen platformbeoordelingen om op te wachten. Verbind WhatsApp, Instagram, TikTok of een ander kanaal, vraag je AI om te posten, te reageren of een rapport te maken, en zie het aan het werk.

  • 3 dagen gratis
  • Op elk moment opzegbaar
  • Alleen officiële API's
  • 24/7 bewaakt

Geverifieerd op