Zaloguj sięRozpocznij bezpłatny okres próbny
easyCoexistence Oficjalne API

Publikuj na Instagramie, TikTok i Facebooku z Pythona jednym API

Dzięki easyCoexistence kod w Pythonie publikuje posty na Instagramie, Facebooku, TikTok, YouTube i LinkedIn przez oficjalne API każdej sieci. Każde konto loguje się raz, przez gotowy link. Potem skrypt pobiera świeży token TikToka, YouTube lub LinkedIn jednym żądaniem GET, a wywołania na Instagramie i Facebooku idą przez narzędzia MCP easyCoexistence, które przechowują token. Narzędzia MCP dają agentowi w Pythonie te same konta.

1,000 bytes

Najwięcej tekstu, jaki jedna wiadomość DM na Instagramie może przenieść przez API, liczony w UTF-8, więc emoji zajmują więcej miejsca.

24 hours

Jak długo ważny jest token dostępu TikTok API for Business; jego token odświeżania pozostaje ważny przez rok.

1 hour

Jak długo ważny jest token dostępu użytkownika Google, czyli ten, który przenosi każde wywołanie YouTube API.

OAuthClientProvider

Moduł OAuth z MCP Python SDK, który rejestruje klienta, przeprowadza logowanie z PKCE i odświeża tokeny.

1 attempt

Przekazywane zdarzenia dotyczące komentarzy, wzmianek i wiadomości prywatnych są dostarczane tylko raz i nie są przechowywane, dlatego każde potwierdź od razu.

Skąd Python bierze token dla Instagrama, Facebooka, TikToka, YouTube czy LinkedIn?

Przez sesję połączenia w Partner API easyCoexistence, uwierzytelnioną kluczem ec_live_. POST /connect-sessions z channel ustawionym na instagram, facebook, tiktok, youtube lub linkedin zwraca hostowany link dla jednego klienta, ważny godzinę. Klient loguje się własnym logowaniem danej sieci i trafia na Twój redirect_url ze status=connected oraz channel_id. Twój backend ma to potwierdzić przez GET /connect-sessions/{session}, a nie ufać parametrom w zapytaniu. Twój kod nigdy nie potrzebuje własnej aplikacji developerskiej w Meta, TikToku, Google ani LinkedIn.

Potem pytaj o dane uwierzytelniające na początku każdego zadania. GET /channels/{id}?credentials=1 zwraca bazowy adres API sieci, identyfikator konta w tej sieci oraz, dla TikToka, YouTube i LinkedIn, token dostępu, który easyCoexistence utrzymuje odnawianym. Token TikToka działa 24 godziny, a Google'a godzinę, więc pobieraj go przy każdym zadaniu zamiast zapisywać. Tokeny Instagrama i Facebooka nigdy nie są wydawane; ich wywołania idą przez narzędzia 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

Jak z Pythona publikować na Instagramie i Facebooku?

Instagram publikuje w dwóch krokach w Graph API Meta, z tokenem w nagłówku bearer. POST /{ig-id}/media z image_url i caption tworzy kontener; gdy GET jego status_code zwróci FINISHED, POST /{ig-id}/media_publish z kontenerem jako creation_id umieszcza post na profilu. Meta radzi sprawdzać mniej więcej co minutę, przez maksymalnie 5 minut. Reel idzie tymi samymi krokami, wysłany z media_type REELS i video_url zamiast obrazu.

Post na stronie Facebooka to jedno wywołanie: POST /{page-id}/feed z message i, jeśli chcesz, link. Dodanie published false oraz scheduled_publish_time między 10 minutami a 30 dniami w przód sprawia, że Meta opublikuje go o tej porze, bez działającego zadania po Twojej stronie. Meta pobiera media z publicznego URL w obu przypadkach, a Instagram przyjmuje tylko obrazy 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"]

Jak z Pythona wysyłać wideo na YouTube i publikować na LinkedIn?

YouTube przyjmuje wideo jako wznawialne przesłanie. Pierwsze żądanie idzie na endpoint wysyłania z uploadType=resumable i part=snippet,status, niesie tytuł oraz status jako JSON; nagłówek Location odpowiedzi to adres sesji. PUT pliku pod ten adres odpowiada 201 z nowym wideo. Ustawienie privacyStatus na private z czasem publishAt pozwala YouTube opublikować wideo samodzielnie o tej porze, a selfDeclaredMadeForKids zapisuje, czy film jest przeznaczony dla dzieci.

LinkedIn przyjmuje jedno POST na /rest/posts z tokenem bearer, nagłówkiem LinkedIn-Version i X-Restli-Protocol-Version 2.0.0. Treść wskazuje autora, niesie tekst jako commentary i ustawia visibility, distribution oraz lifecycleState. Dane uwierzytelniające dostarczają author_urn, czyli urn:li:organization dla strony firmowej albo urn:li:person dla profilu, oraz wersję, której używa easyCoexistence. URN nowego posta wraca w nagłówku 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

Jak z Pythona czytać komentarze i odpowiadać na komentarze oraz DM-y?

Włącz przekazywanie dla kanału, weryfikuj każde dostarczenie, a potem odpowiadaj przez API danej sieci. PUT /channels/{id}/webhook z url zwraca signing_secret, pokazywany tylko raz. Komentarze, wzmianki i DM-y na Instagramie i Facebooku oraz komentarze na TikToku przychodzą jako POST z platform, account_id, external_id i entry, przy czym entry dokładnie w takiej postaci, w jakiej wysłała je sieć. Nagłówek X-EC-Signature ma postać t=<unix>,v1=<hex>, a v1 to HMAC-SHA256 znacznika czasu, kropki i surowej treści. Każde zdarzenie wysyłane jest raz, bez kopii i bez ponownej próby, więc najpierw potwierdź odbiór, a pracuj z kolejki.

Odpowiedź na DM na Instagramie idzie na /{ig-id}/messages w ciągu 24 godzin od ostatniej wiadomości tej osoby, do 1 000 bajtów. Na komentarz odpowiesz publicznie pod /{comment-id}/replies albo jedną prywatną odpowiedzią w ciągu 7 dni. Komentarze na TikToku dostają publiczne odpowiedzi przez business/comment/reply/create/, bo na TikToku nie ma DM-ów. Komentarze na YouTube i LinkedIn czytasz przez ich API według harmonogramu.

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)

Jak z Pythona publikować na TikToku?

Przez narzędzie MCP publish_tiktok_post w easyCoexistence. API TikToka for Business przyjmuje wideo jako video_url i od 16 listopada 2023 pobiera je tylko z domeny lub prefiksu URL zweryfikowanego dla aplikacji developerskiej, do której należy token, czyli aplikacji easyCoexistence. Narzędzie przyjmuje Twój link HTTPS i przekazuje TikTokowi podpisany adres w zweryfikowanej trasie mediów easyCoexistence, strumieniując plik bez jego zapisywania. Posty ze zdjęciami przyjmują zamiast tego image_urls, od 1 do 35 plików JPEG lub WebP, a get_tiktok_publish_status śledzi post, gdy TikTok go przetwarza.

Z Pythona to jedno wywołanie przez oficjalny MCP SDK w wersji 2, na Pythonie 3.10 lub nowszym. Serwer pod https://easycoexistence.com/api/mcp przyjmuje wyłącznie OAuth 2.1, więc OAuthClientProvider z SDK rejestruje Twojego klienta, przeprowadza jedno logowanie w przeglądarce z PKCE i odświeża tokeny. Tokeny dostępu działają godzinę, a tokeny odświeżania 60 dni. Każde odświeżenie wydaje nową parę, a magazyn, który je trwale przechowuje, utrzymuje backend zalogowany.

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

Jak agent AI w Pythonie korzysta z tych kont?

Przez tę samą sesję MCP. Serwer wylicza narzędzia dla sieci na Twoim koncie, a każdy framework agentów, który przyjmuje narzędzia MCP, może przekazać je swojemu modelowi: publikować w każdej sieci, wyświetlać posty, czytać komentarze i na nie odpowiadać, odpowiadać na DM-y na Instagramie i Facebooku, ustawiać reguły z komentarza do DM oraz czytać statystyki i analizy. Instrukcje serwera i opis każdego narzędzia niosą zasady danej sieci, więc model wie, że odpowiedzi na TikToku są publiczne, a obrazy na Instagramie muszą być JPEG.

Zacznij agenta od list_social_accounts, bo każde inne narzędzie społecznościowe bierze z niego account_id. Ten identyfikator to ten sam channel id, który zwraca Partner API. Odpowiedzi, które muszą wyjść o 3 w nocy bez działającego agenta, należą do reguł komentarzy i automatyzacji, które działają na samym easyCoexistence.

Typowe błędy

  • Zapisywanie tokenu w pliku konfiguracyjnym. Token TikToka wygasa w ciągu doby, a Google'a w ciągu godziny, a easyCoexistence odnawia je w tle, więc wywołuj endpoint danych uwierzytelniających na początku każdego zadania.
  • Podawanie TikTokowi linku z własnej domeny. TikTok pobiera media tylko z prefiksów URL zweryfikowanych dla aplikacji, która trzyma token, więc publikuj przez publish_tiktok_post, które serwuje Twój plik spod zweryfikowanego adresu easyCoexistence.
  • Odpowiadanie na każde zdarzenie komentarza, także własne. Twoje publiczne odpowiedzi wracają jako nowe komentarze, a wiadomości na Instagramie jako echa, więc pomijaj zdarzenia, których autorem jest samo konto, inaczej bot odpowie sam sobie.
  • Liczenie DM-ów na Instagramie w znakach. Limit to 1 000 bajtów UTF-8, więc tekst z emoji lub literami z diakrytykami szybciej go wyczerpie; przycinaj go według zakodowanej długości przed wysłaniem.
Z EasyCoexistence zrobisz to

easyCoexistence daje Twojemu kodowi w Pythonie i agentom AI dostęp do klientów w WhatsAppie, Instagramie, Facebooku, TikToku, YouTube, LinkedIn i kolejnych kanałach, przez oficjalne API każdej sieci. Partner API łączy konta i wydaje świeże tokeny, serwer MCP daje agentom te same konta jako narzędzia, a każde połączenie jest monitorowane 24/7. Od US$ 9 do US$ 0.75 za połączenie miesięcznie, im więcej połączeń, tym taniej, z bezpłatnym okresem próbnym przez pierwsze 3 dni.

Najczęściej zadawane pytania

Czy potrzebuję własnej aplikacji developerskiej w Meta, TikToku, Google lub LinkedIn?

Nie. Konta logują się przez własną aplikację easyCoexistence w każdej sieci, a wywołanie danych uwierzytelniających przekazuje Twojemu kodowi token tego konta w TikToku, YouTube i LinkedIn, gotowy do użycia w API danej sieci.

Jakiej wersji Pythona i bibliotek potrzebuję?

Partner API i API sieci to zwykłe HTTPS z JSON, więc wywołuje je requests, httpx lub dowolny inny klient HTTP dla Pythona. MCP Python SDK w wersji 2, z którego korzystają publikacja na TikToku i narzędzia agentów, wymaga Pythona 3.10 lub nowszego.

Które sieci wysyłają komentarze i DM-y do mojego endpointu?

Instagram i Facebook przekazują komentarze, wzmianki i DM-y, a TikTok przekazuje komentarze; każde zdarzenie jest podpisane sekretem kanału. YouTube i LinkedIn nie wysyłają takich zdarzeń, więc ich komentarze czytaj przez API według harmonogramu.

Ile kosztuje easyCoexistence dla Pythona?

Od US$ 9 do US$ 0.75 za połączenie miesięcznie, im więcej połączeń, tym taniej, i ta sama cena w każdej sieci. Partner API i konektor MCP są w cenie, bez opłat za miejsca, a pierwsze 3 dni to bezpłatny okres próbny.

Czytaj dalej

Połącz pierwszy kanał w dwie minuty.

Bez czekania na weryfikację przez platformy. Połącz WhatsApp, Instagram, TikTok lub inny kanał, a potem poproś swoją AI o opublikowanie posta, odpowiedź lub raport i zobacz, jak działa.

  • 3 dni za darmo
  • Rezygnacja w każdej chwili
  • Tylko oficjalne API
  • Monitorowanie 24/7

Zweryfikowano w