Publique no Instagram, TikTok e Facebook com Python usando uma única API
Com o easyCoexistence, o código Python publica no Instagram, Facebook, TikTok, YouTube e LinkedIn pela API oficial de cada rede. Cada conta faz login uma vez por um link hospedado; depois, seu script busca um token novo do TikTok, do YouTube ou do LinkedIn com um GET, enquanto as chamadas do Instagram e do Facebook passam pelas ferramentas MCP do easyCoexistence, que guardam o token. As ferramentas MCP dão a um agente Python as mesmas contas.
O maior texto que uma DM do Instagram pode levar pela API, contado em UTF-8, então emojis ocupam mais espaço.
Por quanto tempo dura um token de acesso da API for Business do TikTok; seu refresh token permanece válido por um ano.
Por quanto tempo dura um token de acesso de usuário do Google, o tipo que toda chamada à API do YouTube carrega.
O handler OAuth do SDK Python do MCP, que registra o cliente, executa o login com PKCE e renova os tokens.
Eventos encaminhados de comentário, menção e DM são entregues uma única vez e nunca armazenados, então confirme cada um imediatamente.
Como o Python obtém um token para Instagram, Facebook, TikTok, YouTube ou LinkedIn?
Por uma sessão de conexã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 retorna um link hospedado para um cliente, válido por uma hora. O cliente faz login com o próprio login da rede e volta 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. Seu código não precisa de um app de desenvolvedor próprio 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 retorna a base da API da rede, o id da conta nessa rede e, no TikTok, no YouTube e no 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 busque-o a cada tarefa em vez de salvá-lo. Os tokens do Instagram e do Facebook nunca são entregues; 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 publicar no Instagram e no Facebook com Python?
O Instagram publica em duas etapas pela Graph API da Meta, com o token em um cabeçalho bearer. POST /{ig-id}/media com image_url e caption cria um container; quando um GET do status_code retorna FINISHED, POST /{ig-id}/media_publish com o container como creation_id publica no perfil. A Meta sugere verificar cerca de uma vez por minuto, por 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 em Página do Facebook é uma única chamada: POST /{page-id}/feed com message e, se quiser, um link. Adicionar published como false e um scheduled_publish_time entre 10 minutos e 30 dias à frente faz a Meta publicar naquele momento, sem nenhuma tarefa sua rodando. A Meta baixa a mídia de uma URL pública 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 enviar vídeo ao YouTube e publicar no LinkedIn com Python?
O YouTube recebe o vídeo como upload retomável. A primeira requisição vai para o endpoint de upload com uploadType=resumable e part=snippet,status e leva o título e o status em JSON; o cabeçalho Location da resposta é o endereço da sessão. Um PUT do arquivo para esse endereço responde 201 com o novo vídeo. Definir privacyStatus como private com um horário em publishAt faz o YouTube publicar o vídeo sozinho naquele momento, e selfDeclaredMadeForKids registra se ele é feito para 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, traz o texto em commentary e define visibility, distribution e lifecycleState. As credenciais fornecem 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; a 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 ler e responder comentários e DMs com Python?
Ative o encaminhamento para o canal, verifique cada entrega e depois responda pela API da rede. PUT /channels/{id}/webhook com uma url retorna um signing_secret, mostrado apenas uma vez. Comentários, menções e DMs no Instagram e no Facebook, e comentários no TikTok, chegam então como um POST com platform, account_id, external_id e entry, com 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 do timestamp, de um ponto e do corpo bruto. Cada evento é enviado uma vez, sem cópia guardada e sem repetir o envio; então confirme primeiro e trabalhe a partir de uma fila.
Uma resposta a uma DM do Instagram vai para /{ig-id}/messages em até 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 em até 7 dias. Os comentários do TikTok recebem respostas públicas por business/comment/reply/create/, porque não há DMs no TikTok; já os comentários do YouTube e do LinkedIn são lidos pelas suas APIs em uma agenda.
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 publicar no TikTok com Python?
Pela 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, baixa apenas de um domínio ou prefixo de URL verificado para o app de desenvolvedor por trás do token, que é do easyCoexistence. A ferramenta recebe o seu link HTTPS e entrega ao TikTok um endereço assinado na rota de mídia verificada do easyCoexistence, transmitindo o arquivo sem armazená-lo. Publicações de foto recebem image_urls em vez disso, de 1 a 35 arquivos JPEG ou WebP, e get_tiktok_publish_status acompanha a publicação enquanto o TikTok a processa.
Do Python, isso é uma única chamada pelo SDK oficial do MCP, versão 2, com Python 3.10 ou superior. O servidor em https://easycoexistence.com/api/mcp aceita apenas OAuth 2.1, então o OAuthClientProvider do SDK registra o seu cliente, executa um único login no navegador com PKCE e renova os tokens. Tokens de acesso duram uma hora e refresh tokens 60 dias; cada renovação emite um novo par, e um armazenamento que persista esses tokens mantém o backend autenticado.
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 um agente de IA em Python usa essas contas?
Pela mesma sessão MCP. O servidor lista as ferramentas das redes da sua conta, e qualquer framework de agentes que aceite ferramentas MCP pode passá-las ao seu modelo: publicar em cada rede, listar publicações, ler comentários e respondê-los, responder DMs no Instagram e no Facebook, definir regras de comentário para DM e ler insights e analytics. As instruções do servidor e a descrição de cada ferramenta trazem as regras de cada rede, então o modelo aprende que respostas no TikTok são públicas e que imagens no Instagram precisam ser JPEG.
Inicie o agente com list_social_accounts, já que todas as outras ferramentas sociais recebem um account_id dela, e esse id é o mesmo channel id que a Partner API retorna. Respostas que precisam sair às 3h, sem agente rodando, ficam com as regras de comentário e as automações, que rodam no próprio easyCoexistence.
Erros comuns
- Salvar o token em um arquivo de configuração. O do TikTok expira em menos de um dia e o do Google em menos de uma hora, e o easyCoexistence os renova nos bastidores; por isso chame o endpoint de credenciais no início de cada tarefa.
- Dar ao TikTok um link do seu próprio domínio. O TikTok baixa mídia apenas de prefixos de URL verificados para o app que detém o token; por isso publique pela publish_tiktok_post, que serve o seu arquivo pelo endereço verificado do easyCoexistence.
- Responder a cada evento de comentário, inclusive o seu próprio. Suas respostas públicas voltam como novos comentários e as suas DMs no Instagram como ecos; então ignore eventos cujo autor seja a própria conta, senão o bot responde a si mesmo.
- Medir uma DM do Instagram em caracteres. O limite é de 1,000 bytes em UTF-8, então textos com emojis ou letras acentuadas acabam antes; corte pelo tamanho codificado antes de enviar.
O easyCoexistence dá ao seu código Python e aos seus agentes de IA alcance a clientes no WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn e outros canais, pela API oficial de cada rede. A Partner API conecta contas e entrega tokens sempre renovados, o servidor MCP dá aos agentes as mesmas contas como ferramentas, e cada conexão é monitorada 24/7. De US$ 9 a US$ 0.75 por conexão por mês, com a faixa caindo conforme você adiciona conexões, e os primeiros 3 dias grátis.
O easyCoexistence é uma API e um servidor MCP multicanal que conecta agentes de IA, como o Claude e o ChatGPT, ao WhatsApp, Instagram, TikTok, Facebook e mais. No WhatsApp, ele usa o Coexistence: a empresa continua usando o número no app WhatsApp Business enquanto a IA trabalha pela API oficial da Meta.
Perguntas frequentes
Preciso de um app de desenvolvedor próprio na Meta, no TikTok, no Google ou no LinkedIn?
Não. As contas fazem login pelo app do próprio easyCoexistence em cada rede, e a chamada de credenciais entrega ao seu código o token daquela conta no TikTok, no YouTube e no LinkedIn, pronto para usar na API da rede.
Qual versão do Python e quais bibliotecas eu preciso?
A Partner API e as APIs das redes são HTTPS simples com JSON, então requests, httpx ou qualquer outro cliente HTTP do Python as chama. O SDK Python do MCP, versão 2, que a publicação no TikTok e as ferramentas de agente usam, exige Python 3.10 ou superior.
Quais redes enviam comentários e DMs para o meu endpoint?
Instagram e Facebook encaminham comentários, menções e DMs, e o TikTok encaminha comentários, todos assinados com o segredo do canal. YouTube e LinkedIn não enviam esses eventos, então leia os comentários deles pelas suas APIs em uma agenda.
Quanto custa o easyCoexistence para Python?
De US$ 9 a US$ 0.75 por conexão por mês, caindo conforme você adiciona conexões, o mesmo em todas as redes. A Partner API e o conector MCP estão incluídos, sem assentos, e os primeiros 3 dias são grátis.
Continue lendo
Conecte seu primeiro canal em dois minutos.
Sem esperar aprovação das plataformas. Conecte o WhatsApp, o Instagram, o TikTok ou outro canal, peça para a sua IA publicar, responder ou trazer os números, e veja funcionando.
- 3 dias grátis
- Cancele quando quiser
- Só APIs oficiais
- Monitorado 24/7
Verificado em