InloggenGratis proefperiode starten
easyCoexistence Officiële API's

Geef een OpenAI Agents SDK-agent tools voor Instagram, TikTok en WhatsApp

Een OpenAI Agents SDK-agent krijgt Instagram-, TikTok-, WhatsApp- en meer kanalen als tools via MCPServerStreamableHttp, gericht op https://easycoexistence.com/api/mcp, met de OAuthClientProvider van de MCP Python SDK als authenticatiehandler. Een tool-filter beperkt de 35+ tools tot de taak, require_approval houdt publicatie tegen tot een persoon goedkeurt, en elke aanroep bereikt het netwerk via de officiële API.

httpx2.Auth

Wat MCPServerStreamableHttp in params["auth"] verwacht bij MCP Python SDK v2; bij v1 is dat een httpx.Auth.

mcp>=1.19.0,<3

Het bereik van het mcp-pakket waarvan de Agents SDK afhankelijk is, dat beide hoofdversies van de MCP Python SDK omvat.

interruptions

Waar een gepauzeerde run de tool-aanroepen toont die op goedkeuring wachten, die een RunState goedkeurt of afwijst voordat Runner.run verdergaat.

Per request

Hoe vaak de MCP-tool van de Responses API zijn OAuth-token in authorization moet krijgen; OpenAI bewaart de waarde niet.

40 a minute

Aantal aanroepen dat TikTok toestaat per gekoppeld account op elk eindpunt van de Accounts API, inclusief antwoorden op reacties.

Hoe verbindt een Agents SDK-agent zich met easyCoexistence?

Via MCPServerStreamableHttp, met de OAuthClientProvider van de MCP Python SDK in params["auth"]. De Agents SDK geeft die handler door aan de HTTP-client die hij bouwt, zodat de provider de autorisatieserver van easyCoexistence vindt, je agent registreert als public client, één keer inloggen in de browser uitvoert met PKCE en de toegangstokens die een uur geldig zijn vernieuwt met het refresh-token. Het voorbeeld gebruikt MCP Python SDK v2, waar de handler een httpx2.Auth moet zijn, wat de provider is. Een opslagobject bewaart de registratie en de tokens tussen runs; het onderstaande bestand staat in voor een geheimenopslag. create_static_tool_filter bepaalt welke tools de agent ziet, en require_approval noemt de tools die op een persoon wachten.

The MCP server, signed in over OAuth, with a filter and approvals
import json, webbrowser
from pathlib import Path
from urllib.parse import parse_qs, urlparse

from pydantic import AnyUrl
from mcp.client.auth import AuthorizationCodeResult, OAuthClientProvider
from mcp.shared.auth import OAuthClientInformationFull, OAuthClientMetadata, OAuthToken
from agents.mcp import MCPServerStreamableHttp, create_static_tool_filter

URL = "https://easycoexistence.com/api/mcp"
SAVED = Path("easycoexistence-oauth.json")  # a secret store in production

class SavedSignIn:  # the MCP SDK's TokenStorage: registration and tokens survive restarts
    def _read(self) -> dict:
        return json.loads(SAVED.read_text()) if SAVED.exists() else {}
    def _write(self, key: str, model) -> None:
        data = self._read()
        data[key] = model.model_dump(mode="json")
        SAVED.write_text(json.dumps(data))
    async def get_tokens(self):
        t = self._read().get("tokens")
        return OAuthToken(**t) if t else None
    async def set_tokens(self, tokens): self._write("tokens", tokens)
    async def get_client_info(self):
        c = self._read().get("client")
        return OAuthClientInformationFull(**c) if c else None
    async def set_client_info(self, info): self._write("client", info)

async def open_sign_in(url: str) -> None:
    webbrowser.open(url)

async def code_from_redirect() -> AuthorizationCodeResult:
    q = parse_qs(urlparse(input("Address after sign-in: ")).query)
    return AuthorizationCodeResult(code=q["code"][0], state=q["state"][0])

oauth = OAuthClientProvider(
    server_url=URL,
    client_metadata=OAuthClientMetadata(
        client_name="Social desk agent",  # shown on easyCoexistence's consent screen
        redirect_uris=[AnyUrl("http://localhost:3030/callback")],
        scope="mcp",
    ),
    storage=SavedSignIn(),
    redirect_handler=open_sign_in,
    callback_handler=code_from_redirect,
)

PUBLISH = ["publish_instagram_post", "publish_tiktok_post", "publish_facebook_post"]

def easycoexistence() -> MCPServerStreamableHttp:
    return MCPServerStreamableHttp(
        name="easyCoexistence",
        params={"url": URL, "auth": oauth, "timeout": 60},
        client_session_timeout_seconds=60,  # publishing waits on the network's API
        cache_tools_list=True,
        tool_filter=create_static_tool_filter(allowed_tool_names=[
            "list_social_accounts", "list_social_posts", "list_social_comments",
            "reply_to_comment", "list_scheduled_posts", *PUBLISH,
        ]),
        require_approval={"always": {"tool_names": PUBLISH}},
    )

Hoe houd je publicatie achter goedkeuring van een persoon?

Met require_approval op de server, die de run pauzeert voordat een genoemde tool wordt uitgevoerd. De run keert dan terug met interruptions in plaats van een eindantwoord: zet het resultaat om in een RunState, keur elke openstaande aanroep goed of af, en roep Runner.run opnieuw aan met dezelfde agent en de state. Met always_approve op False geldt elk ja voor één aanroep, zodat de agent een goedkeuring niet voor een tweede post kan hergebruiken. De server blijft open tijdens de pauze, omdat de lus binnen zijn async with-blok draait. Voor een review die uren duurt, kan de SDK de state als JSON opslaan en later laden met RunState.from_json.

Run the agent and resume it after each decision
from agents import Agent, Runner

RULES = "You run Acme's social accounts. Schedule posts with scheduled_at; TikTok replies are public."

async def run(task: str) -> str:
    async with easycoexistence() as server:
        agent = Agent(name="Social desk", instructions=RULES, mcp_servers=[server])
        result = await Runner.run(agent, task)
        while result.interruptions:  # a publish tool is waiting for a decision
            state = result.to_state()
            for item in result.interruptions:
                if await ask_a_person(item):  # your review screen, chat message or queue
                    state.approve(item, always_approve=False)
                else:
                    state.reject(item)
            result = await Runner.run(agent, state)
        return result.final_output

Hoe start een TikTok-reactie of een Instagram-DM een run?

Via je eigen HTTPS-route, want de agent hoort alleen wat hij bij de MCP-server opvraagt. set_social_webhook_destination richt de reacties, vermeldingen en DM's van een account op de route en geeft één keer een ondertekeningsgeheim terug; TikTok-accounts sturen reacties door. De route controleert X-EC-Signature, een HMAC-SHA256 van de timestamp, een punt en de ruwe body, antwoordt binnen de 8 seconden van easyCoexistence en zet het event in de wachtrij. Een worker roept daarna Runner.run aan met het event als input. Bij DM's houdt een sessie, gekoppeld aan het account en de afzender, het gesprek gaande; een TikTok-reactie heeft alleen de reactie en de bijbehorende video nodig, dus die kan zonder sessie draaien.

Wat moeten de instructies van de agent over elk netwerk zeggen?

De regels die de API van elk netwerk op het account toepast, geschreven op de plek waar het model ze leest:

  • TikTok: reply_to_comment plaatst openbaar en heeft het video-ID als post_id nodig; send_social_dm weigert TikTok-accounts.
  • TikTok-volume: tot 40 aanroepen per minuut per account op het reply-endpoint, en veel bijna identieke antwoorden in korte tijd kunnen als spam worden verborgen.
  • Instagram-DM's: antwoorden alleen aan mensen die in de afgelopen 24 uur schreven, in maximaal 1.000 bytes UTF-8-tekst.
  • WhatsApp: send_message binnen 24 uur na het laatste bericht van de klant, en anders send_template met een goedgekeurde template.
  • Timing: scheduled_at accepteert ISO 8601 met een tijdzone, 1 minuut tot 90 dagen vooruit, en list_scheduled_posts toont de wachtrij.

Kan de agent HostedMCPTool gebruiken, of draaien zonder inloggen?

Beide, met afwegingen. HostedMCPTool geeft de server door aan de Responses API, waarvan de MCP-tool een OAuth-toegangstoken in authorization neemt en dat bij elk verzoek nodig heeft, omdat OpenAI het niet bewaart; een toegangstoken van easyCoexistence is een uur geldig, dus je code vernieuwt er één vóór elke run. Voor een taak waarbij niemand kan inloggen, sla je MCP over: function tools die de Partner API aanroepen met een ec_live_-sleutel kunnen posts in de wachtrij zetten via POST /api/v1/channels/:id/posts en verse TikTok-, YouTube- en LinkedIn-tokens ophalen via GET /api/v1/channels/:id?credentials=1, terwijl reactieregels en automatiseringen zonder draaiende agent antwoorden op easyCoexistence.

Veelgemaakte fouten

  • De client_session_timeout_seconds van 5 seconden behouden voor publicatie. Een publicatie wacht op de API van het netwerk, dus een trage aanroep kan in de agent time-outen nadat easyCoexistence de post al heeft doorgegeven; geef een minuut de ruimte en controleer list_scheduled_posts voordat je opnieuw probeert.
  • external_id doorgeven als account_id. De tools vragen om account_id, het ID van het account bij easyCoexistence; external_id is het eigen ID van het account op Instagram, TikTok of Facebook.
  • Interruptions in een lus goedkeuren zonder persoon erin. require_approval beschermt publicatie alleen als een mens, of een regel die je vertrouwt, over elke openstaande aanroep beslist.
  • De agent de eigen activiteit van het account voeren. Instagram geeft de DM's van het account terug als echo's met is_echo true en de openbare antwoorden als nieuwe reacties; filter beide eruit voordat je Runner.run aanroept.
Dit doen met EasyCoexistence

easyCoexistence geeft je OpenAI Agents SDK-agents bereik tot klanten op WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn en meer kanalen, elk via de officiële API: een MCP-server die met OAuth inlogt, ondertekende events voor reacties en DM's, en een Partner API voor taken die zonder toezicht draaien, met elke verbinding 24/7 bewaakt. US$ 9 tot US$ 0,75 per verbinding per maand, dalend naarmate je verbindingen toevoegt, met de eerste 3 dagen gratis.

Veelgestelde vragen

Heeft de agent een API-sleutel van easyCoexistence nodig?

Niet voor MCP. De OAuth-inlog geeft de agent zijn eigen tokens; een ec_live_-sleutel uit het dashboard is alleen voor code die de Partner API aanroept in plaats van de MCP-server.

Kan dezelfde agent op WhatsApp-berichten antwoorden?

Ja, met de tools van het nummer: list_numbers voor de connection_id, send_message binnen 24 uur na het laatste bericht van de klant en send_template daarbuiten. De gids van de OpenAI Agents SDK over WhatsApp behandelt het ontvangen van de berichten.

Welk model gebruikt de agent?

Het model dat je aan de Agent geeft. De MCP-tools werken hetzelfde, welk model de SDK ook draait; het gebruik van het model wordt door de aanbieder gefactureerd, en easyCoexistence rekent per verbinding.

Hoeveel kost easyCoexistence voor een OpenAI Agents SDK-agent?

US$ 9 tot US$ 0,75 per verbinding per maand, dalend naarmate je verbindingen toevoegt, hetzelfde op elk netwerk. De MCP-server, de doorgestuurde events en de Partner API zijn erbij inbegrepen, en de eerste 3 dagen zijn gratis.

Lees verder

Koppel je eerste kanaal in twee minuten.

Geen platformbeoordelingen om op te wachten. Verbind WhatsApp, Instagram, TikTok of een ander kanaal, vraag je AI om te posten, te reageren of een rapport te maken, en zie het aan het werk.

  • 3 dagen gratis
  • Op elk moment opzegbaar
  • Alleen officiële API's
  • 24/7 bewaakt

Geverifieerd op