Publica en Instagram, TikTok y Facebook desde Python con una sola API
Con easyCoexistence, tu código Python publica en Instagram, Facebook, TikTok, YouTube y LinkedIn mediante la API oficial de cada red. Cada cuenta inicia sesión una vez a través de un enlace alojado; después, tu script obtiene un token nuevo de TikTok, YouTube o LinkedIn con un GET, mientras que las llamadas de Instagram y Facebook pasan por las herramientas MCP de easyCoexistence, que mantienen el token. Las herramientas MCP dan a un agente Python las mismas cuentas.
El texto más largo que cabe en un DM de Instagram a través de la API, contado en UTF-8, así que los emojis ocupan más espacio.
Cuánto dura un token de acceso de la API para Business de TikTok; su token de actualización sigue válido durante un año.
Cuánto dura un token de acceso de usuario de Google, el que lleva cada llamada a la API de YouTube.
El manejador OAuth del SDK de Python de MCP, que registra el cliente, ejecuta el inicio de sesión con PKCE y renueva los tokens.
Los eventos reenviados de comentarios, menciones y DMs se entregan una sola vez y no se almacenan, así que confirma cada uno de inmediato.
¿Cómo obtiene Python un token para Instagram, Facebook, TikTok, YouTube o LinkedIn?
Mediante una sesión de conexión en la Partner API de easyCoexistence, autenticada con tu clave ec_live_. POST /connect-sessions con channel configurado como instagram, facebook, tiktok, youtube o linkedin devuelve un enlace alojado para un solo cliente, válido durante una hora. Inicia sesión con el login propio de la red y llega a tu redirect_url con status=connected y un channel_id, que tu backend confirma con GET /connect-sessions/{session} en lugar de fiarse de la cadena de consulta. Tu código nunca necesita una app de desarrollador propia en Meta, TikTok, Google o LinkedIn.
Luego pide las credenciales al inicio de cada tarea. GET /channels/{id}?credentials=1 devuelve la base de la API de la red, el id de la cuenta en esa red y, para TikTok, YouTube y LinkedIn, un token de acceso que easyCoexistence mantiene renovado. El token de TikTok dura 24 horas y el de Google una hora, así que pídelo por tarea en lugar de guardarlo. Los tokens de Instagram y Facebook nunca se entregan; sus llamadas pasan por las herramientas 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 creds¿Cómo publicar en Instagram y Facebook desde Python?
Instagram publica en dos pasos con la API Graph de Meta, con el token como encabezado bearer. POST /{ig-id}/media con un image_url y un caption crea un contenedor; cuando un GET de su status_code devuelve FINISHED, POST /{ig-id}/media_publish con el contenedor como creation_id lo publica en el perfil. Meta recomienda consultar aproximadamente una vez por minuto, durante hasta cinco minutos. Un Reel sigue los mismos pasos, enviado con media_type REELS y un video_url en lugar de una imagen.
Una publicación en una página de Facebook es una sola llamada: POST /{page-id}/feed con un message y, si lo quieres, un link. Añadir published false y un scheduled_publish_time entre 10 minutos y 30 días después hace que Meta la publique en ese momento, sin ningún trabajo tuyo en marcha. Meta descarga los medios desde una URL pública en ambos casos, e Instagram acepta solo imágenes 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"]¿Cómo subir a YouTube y publicar en LinkedIn desde Python?
YouTube recibe el video como carga reanudable. La primera petición va al endpoint de carga con uploadType=resumable y part=snippet,status y lleva el título y el estado como JSON; el encabezado Location de su respuesta es la dirección de la sesión. Un PUT del archivo a esa dirección responde 201 con el nuevo video. Si configuras privacyStatus como private con una hora publishAt, YouTube publica el video por sí solo en ese momento, y selfDeclaredMadeForKids indica si está dirigido a niños.
LinkedIn recibe un solo POST a /rest/posts con el token bearer, un encabezado LinkedIn-Version y X-Restli-Protocol-Version 2.0.0. El cuerpo indica el autor, lleva el texto como commentary y configura visibility, distribution y lifecycleState. Las credenciales aportan author_urn, un urn:li:organization para una página de empresa o un urn:li:person para un perfil, y la versión que usa easyCoexistence; el URN de la nueva publicación regresa en el encabezado 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 URN¿Cómo leer y responder comentarios y DMs en Python?
Activa el reenvío del canal, verifica cada entrega y luego responde mediante la API de la red. PUT /channels/{id}/webhook con una url devuelve un signing_secret, que se muestra una sola vez. Los comentarios, menciones y DMs de Instagram y Facebook, y los comentarios de TikTok, llegan entonces como un POST con platform, account_id, external_id y entry, con entry exactamente como lo envió la red. El encabezado X-EC-Signature tiene la forma t=<unix>,v1=<hex>, y v1 es un HMAC-SHA256 de la marca de tiempo, un punto y el cuerpo sin procesar. Cada evento se envía una vez, sin copia guardada y no se reintenta, así que confirma primero y trabaja desde una cola.
Una respuesta a un DM de Instagram va a /{ig-id}/messages dentro de las 24 horas posteriores al último mensaje de la persona, en como máximo 1,000 bytes. Un comentario recibe una respuesta pública en /{comment-id}/replies, o una respuesta privada única dentro de 7 días. Los comentarios de TikTok reciben respuestas públicas mediante business/comment/reply/create/, porque TikTok no tiene DMs, y los comentarios de YouTube y LinkedIn se leen mediante sus API según un calendario.
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)¿Cómo publicar en TikTok desde Python?
Mediante la herramienta MCP publish_tiktok_post de easyCoexistence. La API para Business de TikTok recibe un video como video_url y, desde el 16 de noviembre de 2023, lo descarga solo desde un dominio o prefijo de URL verificado para la app de desarrollador detrás del token, que es la de easyCoexistence. La herramienta toma tu enlace HTTPS y entrega a TikTok una dirección firmada en la ruta de medios verificada de easyCoexistence, transmitiendo el archivo sin guardarlo. Las publicaciones de fotos reciben image_urls en su lugar, de 1 a 35 archivos JPEG o WebP, y get_tiktok_publish_status sigue la publicación mientras TikTok la procesa.
Desde Python, eso es una llamada mediante el SDK oficial de MCP, versión 2, con Python 3.10 o posterior. El servidor en https://easycoexistence.com/api/mcp acepta solo OAuth 2.1, así que OAuthClientProvider del SDK registra tu cliente, ejecuta un solo inicio de sesión en el navegador con PKCE y renueva los tokens. Los tokens de acceso duran una hora y los de actualización 60 días; cada renovación emite un par nuevo, y un almacenamiento que los conserve mantiene con sesión iniciada a un backend.
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())¿Cómo usa un agente de IA en Python estas cuentas?
Mediante la misma sesión MCP. El servidor lista las herramientas de las redes de tu cuenta, y cualquier framework de agentes que acepte herramientas MCP puede entregárselas a su modelo: publicar en cada red, listar publicaciones, leer comentarios y responderlos, responder DMs de Instagram y Facebook, configurar reglas de comentario a DM y leer métricas y analíticas. Las instrucciones del servidor y la descripción de cada herramienta incluyen las reglas de cada red, de modo que el modelo sabe que las respuestas de TikTok son públicas y que las imágenes de Instagram deben ser JPEG.
Inicia el agente con list_social_accounts, ya que cada otra herramienta social toma un account_id de ahí, y ese id es el mismo channel id que devuelve la Partner API. Las respuestas que deban salir a las 3 de la madrugada sin agente en ejecución corresponden a reglas y automatizaciones de comentarios, que se ejecutan en el propio easyCoexistence.
Errores comunes
- Guardar el token en un archivo de configuración. El de TikTok caduca en menos de un día y el de Google en menos de una hora, y easyCoexistence los renueva por detrás, así que llama al endpoint de credenciales al inicio de cada tarea.
- Dar a TikTok un enlace de tu propio dominio. TikTok descarga medios solo desde prefijos de URL verificados para la app que tiene el token, así que publica mediante publish_tiktok_post, que sirve tu archivo desde la dirección verificada de easyCoexistence.
- Responder a cada evento de comentario, incluidos los tuyos. Tus respuestas públicas vuelven como comentarios nuevos y tus DMs de Instagram como eventos de eco, así que omite los eventos cuyo autor es la propia cuenta, o el bot se responderá a sí mismo.
- Medir un DM de Instagram en caracteres. El límite es de 1,000 bytes en UTF-8, así que el texto con emojis o letras acentuadas se agota antes; recorta por longitud codificada antes de enviar.
easyCoexistence da a tu código Python y a tus agentes de IA acceso a clientes en WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn y más canales, mediante la API oficial de cada red. La Partner API conecta cuentas y entrega tokens nuevos, el servidor MCP da a los agentes las mismas cuentas como herramientas, y cada conexión se monitoriza 24/7. De US$ 9 a US$ 0.75 por conexión al mes, bajando a medida que añades conexiones, con los primeros 3 días gratis.
Preguntas frecuentes
¿Necesito mi propia app de desarrollador en Meta, TikTok, Google o LinkedIn?
No. Las cuentas inician sesión mediante la app propia de easyCoexistence en cada red, y la llamada de credenciales entrega a tu código el token de la cuenta en TikTok, YouTube y LinkedIn, listo para usar contra la API de la red.
¿Qué versión de Python y qué bibliotecas necesito?
La Partner API y las API de las redes son HTTPS plano con JSON, así que requests, httpx o cualquier otro cliente HTTP de Python las llama. El SDK de Python de MCP, versión 2, que usan la publicación en TikTok y las herramientas de agentes, requiere Python 3.10 o posterior.
¿Qué redes envían comentarios y DMs a mi endpoint?
Instagram y Facebook reenvían comentarios, menciones y DMs, y TikTok reenvía comentarios, todos firmados con el secreto del canal. YouTube y LinkedIn no envían esos eventos, así que lee sus comentarios mediante sus API según un calendario.
¿Cuánto cuesta easyCoexistence para Python?
US$ 9 a US$ 0.75 por conexión al mes, bajando a medida que añades conexiones, y lo mismo en todas las redes. La Partner API y el conector MCP están incluidos, sin asientos, y los primeros 3 días son gratis.
Sigue leyendo
Conecta tu primer canal en dos minutos.
Sin esperar revisiones de las plataformas. Conecta WhatsApp, Instagram, TikTok u otro canal, pídele a tu IA que publique, responda o te haga un informe, y míralo trabajar.
- 3 días gratis
- Cancela cuando quieras
- Solo APIs oficiales
- Monitorizado 24/7
Verificado el