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.
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.
Jak długo ważny jest token dostępu TikTok API for Business; jego token odświeżania pozostaje ważny przez rok.
Jak długo ważny jest token dostępu użytkownika Google, czyli ten, który przenosi każde wywołanie YouTube API.
Moduł OAuth z MCP Python SDK, który rejestruje klienta, przeprowadza logowanie z PKCE i odświeża tokeny.
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.
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 credsJak 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.
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.
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 URNJak 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.
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.
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.
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