Iniciar sesiónEmpezar prueba gratis
easyCoexistence APIs oficiales

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.

1,000 bytes

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.

24 hours

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.

1 hour

Cuánto dura un token de acceso de usuario de Google, el que lleva cada llamada a la API de YouTube.

OAuthClientProvider

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.

1 attempt

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.

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

¿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.

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"]

¿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.

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

¿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.

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)

¿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.

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

¿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.
Hacerlo con EasyCoexistence

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