Publique no Instagram, TikTok e Facebook a partir de Python com uma só API
Com o easyCoexistence, o código Python publica no Instagram, Facebook, TikTok, YouTube e LinkedIn através da API oficial de cada rede. Cada conta inicia sessão uma vez por uma hiperligação alojada; depois, o script obtém um token novo do TikTok, do YouTube ou do LinkedIn com um GET, enquanto as chamadas ao Instagram e ao Facebook passam pelas ferramentas MCP da easyCoexistence, que mantêm o token. As ferramentas MCP dão a um agente Python as mesmas contas.
O texto máximo que uma DM do Instagram pode transportar pela API, contado em UTF-8, pelo que os emojis ocupam mais espaço.
Quanto tempo dura um token de acesso da API for Business do TikTok; o seu token de atualização mantém-se válido durante um ano.
Quanto tempo se mantém válido um token de acesso de utilizador do Google, o tipo que todas as chamadas à API do YouTube transportam.
O componente OAuth do SDK Python de MCP, que regista o cliente, executa o início de sessão com PKCE e renova os tokens.
Os eventos de comentário, menção e DM reencaminhados são entregues uma só vez e nunca armazenados, pelo que confirme cada um de imediato.
Como é que o Python obtém um token para o Instagram, Facebook, TikTok, YouTube ou LinkedIn?
Através de uma sessão de ligação na Partner API do easyCoexistence, autenticada com a sua chave ec_live_. POST /connect-sessions com channel definido como instagram, facebook, tiktok, youtube ou linkedin devolve uma hiperligação alojada para um cliente, válida durante uma hora. O cliente inicia sessão com o login da própria rede e é reencaminhado para o seu redirect_url com status=connected e um channel_id, que o seu backend confirma com GET /connect-sessions/{session} em vez de confiar na query string. O seu código nunca precisa de uma aplicação de programador própria na Meta, no TikTok, no Google ou no LinkedIn.
Depois, peça as credenciais no início de cada tarefa. GET /channels/{id}?credentials=1 devolve a base da API da rede, o id da conta nessa rede e, para o TikTok, o YouTube e o LinkedIn, um token de acesso que o easyCoexistence mantém renovado. O token do TikTok dura 24 horas e o do Google uma hora, por isso obtenha-o por tarefa em vez de o guardar. Os tokens do Instagram e do Facebook nunca são entregues; as suas chamadas passam pelas ferramentas 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 credsComo publica no Instagram e no Facebook a partir de Python?
O Instagram publica em dois passos na Graph API da Meta, com o token num cabeçalho bearer. POST /{ig-id}/media com um image_url e uma legenda cria um contentor; quando um GET ao seu status_code devolver FINISHED, POST /{ig-id}/media_publish com o contentor como creation_id publica-o no perfil. A Meta sugere verificar cerca de uma vez por minuto, durante até cinco minutos. Um Reel segue os mesmos passos, enviado com media_type REELS e um video_url em vez de uma imagem.
Uma publicação numa página do Facebook é uma só chamada: POST /{page-id}/feed com uma message e, se quiser, um link. Acrescentar published false e um scheduled_publish_time entre 10 minutos e 30 dias à frente faz com que a Meta a publique nesse momento, sem nenhum processo seu em execução. A Meta transfere os ficheiros multimédia a partir de um URL público nos dois casos, e o Instagram aceita apenas imagens 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"]Como carrega para o YouTube e publica no LinkedIn a partir de Python?
O YouTube recebe o vídeo como um upload retomável. O primeiro pedido vai para o endpoint de upload com uploadType=resumable e part=snippet,status e transporta o título e o estado em JSON; o cabeçalho Location da resposta é o endereço da sessão. Um PUT do ficheiro para esse endereço responde com 201 e com o novo vídeo. Definir privacyStatus como private com um horário publishAt permite que o YouTube publique o vídeo por si nesse momento, e selfDeclaredMadeForKids indica se o vídeo é destinado a crianças.
O LinkedIn recebe um único POST para /rest/posts com o token bearer, um cabeçalho LinkedIn-Version e X-Restli-Protocol-Version 2.0.0. O corpo indica o autor, transporta o texto como commentary e define visibility, distribution e lifecycleState. As credenciais fornecem o author_urn, um urn:li:organization para uma página de empresa ou um urn:li:person para um perfil, e a versão que o easyCoexistence usa; o URN da nova publicação volta no cabeçalho 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 URNComo lê e responde a comentários e DMs em Python?
Ative o reencaminhamento para o canal, verifique cada entrega e depois responda através da API da rede. PUT /channels/{id}/webhook com um url devolve um signing_secret, mostrado apenas uma vez. Os comentários, as menções e as DMs no Instagram e no Facebook, e os comentários no TikTok, chegam então como um POST com platform, account_id, external_id e entry, sendo entry exatamente como a rede o enviou. O cabeçalho X-EC-Signature tem o formato t=<unix>,v1=<hex>, e v1 é um HMAC-SHA256 da marca temporal, de um ponto e do corpo em bruto. Cada evento é enviado uma só vez, sem cópia guardada e sem nova tentativa, pelo que confirme primeiro e trabalhe a partir de uma fila.
Uma resposta a uma DM do Instagram segue para /{ig-id}/messages no prazo de 24 horas após a última mensagem da pessoa, com no máximo 1,000 bytes. Um comentário recebe uma resposta pública em /{comment-id}/replies, ou uma única resposta privada no prazo de 7 dias. Os comentários no TikTok recebem respostas públicas através de business/comment/reply/create/, porque não há DMs no TikTok, e os comentários do YouTube e do LinkedIn são lidos através das suas APIs de forma periódica.
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)Como publica no TikTok a partir de Python?
Através da ferramenta MCP publish_tiktok_post do easyCoexistence. A API for Business do TikTok recebe um vídeo como video_url e, desde 16 de novembro de 2023, transfere-o apenas de um domínio ou prefixo de URL verificado para a aplicação de programador que está por trás do token, que é a do easyCoexistence. A ferramenta recebe a sua hiperligação HTTPS e entrega ao TikTok um endereço assinado na rota de multimédia verificada do easyCoexistence, transmitindo o ficheiro sem o guardar. As publicações de fotografia recebem image_urls em vez disso, de 1 a 35 ficheiros JPEG ou WebP, e get_tiktok_publish_status acompanha a publicação enquanto o TikTok a processa.
A partir de Python, é uma chamada através do SDK MCP oficial, versão 2, em Python 3.10 ou posterior. O servidor em https://easycoexistence.com/api/mcp aceita apenas OAuth 2.1, pelo que o OAuthClientProvider do SDK regista o seu cliente, executa um único início de sessão no navegador com PKCE e renova os tokens. Os tokens de acesso duram uma hora e os tokens de atualização 60 dias, e cada renovação emite um par novo; um armazenamento que persista estes dados mantém um backend com sessão iniciada.
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())Como é que um agente de IA em Python usa estas contas?
Através da mesma sessão MCP. O servidor lista as ferramentas das redes na sua conta, e qualquer framework de agentes que aceite ferramentas MCP pode entregá-las ao seu modelo: publicar em cada rede, listar publicações, ler comentários e responder-lhes, responder a DMs no Instagram e no Facebook, definir regras de comentário-para-DM e ler estatísticas e análises. As instruções do servidor e a descrição de cada ferramenta transportam as regras de cada rede, para que o modelo saiba que as respostas no TikTok são públicas e que as imagens do Instagram têm de ser JPEG.
Inicie o agente com list_social_accounts, pois todas as outras ferramentas sociais recebem dela um account_id, e esse id é o mesmo channel id que a Partner API devolve. As respostas que têm de sair às 3 da manhã, sem nenhum agente em execução, ficam a cargo de regras de comentários e automações, que correm no próprio easyCoexistence.
Erros comuns
- Guardar o token num ficheiro de configuração. O do TikTok expira dentro de um dia e o do Google dentro de uma hora, e o easyCoexistence renova-os nos bastidores, por isso chame o endpoint de credenciais no início de cada tarefa.
- Dar ao TikTok uma hiperligação no seu próprio domínio. O TikTok transfere multimédia apenas de prefixos de URL verificados para a aplicação que detém o token, por isso publique através de publish_tiktok_post, que serve o seu ficheiro a partir do endereço verificado do easyCoexistence.
- Responder a cada evento de comentário, incluindo os seus próprios. As suas respostas públicas voltam como novos comentários e as suas DMs do Instagram como ecos, por isso ignore os eventos cujo autor seja a própria conta, ou o bot responde a si mesmo.
- Medir uma DM do Instagram em caracteres. O limite é de 1,000 bytes de UTF-8, por isso um texto com emojis ou letras acentuadas esgota-se mais depressa; corte pelo comprimento codificado antes de enviar.
O easyCoexistence dá ao seu código Python e aos seus agentes de IA alcance junto dos clientes no WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn e mais canais, através da API oficial de cada rede. A Partner API liga contas e entrega tokens novos, o servidor MCP dá aos agentes as mesmas contas como ferramentas, e cada ligação é monitorizada 24/7. De US$ 9 a US$ 0.75 por ligação por mês, a descer à medida que acrescenta ligações, com os primeiros 3 dias gratuitos.
Perguntas frequentes
Preciso da minha própria aplicação de programador na Meta, no TikTok, no Google ou no LinkedIn?
Não. As contas iniciam sessão através da aplicação própria do easyCoexistence em cada rede, e o pedido de credenciais entrega ao seu código o token da conta no TikTok, no YouTube e no LinkedIn, pronto a usar contra a API da rede.
Que versão de Python e que bibliotecas são necessárias?
A Partner API e as APIs das redes são HTTPS simples com JSON, por isso requests, httpx ou qualquer outro cliente HTTP em Python as chama. O SDK Python de MCP, versão 2, que a publicação no TikTok e as ferramentas de agentes usam, requer Python 3.10 ou posterior.
Que redes enviam comentários e DMs para o meu endpoint?
O Instagram e o Facebook reencaminham comentários, menções e DMs, e o TikTok reencaminha comentários, todos assinados com o segredo do canal. O YouTube e o LinkedIn não enviam estes eventos, por isso leia os comentários deles através das suas APIs de forma periódica.
Quanto custa o easyCoexistence para Python?
De US$ 9 a US$ 0.75 por ligação por mês, a descer à medida que acrescenta ligações, e o mesmo em todas as redes. A Partner API e o conector MCP estão incluídos, sem licenças por utilizador, e os primeiros 3 dias são gratuitos.
Continue a ler
Ligue o seu primeiro canal em dois minutos.
Sem revisões de plataformas para esperar. Ligue o WhatsApp, o Instagram, o TikTok ou outro canal, peça depois à sua IA que publique, responda ou faça um relatório, e veja-a trabalhar.
- 3 dias grátis
- Cancele quando quiser
- Só APIs oficiais
- Monitorizado 24/7
Verificado em