MarkaestroMarkaestro

Für KI-Agenten

Verbinde deinen Agenten in einem Schritt. Er betreibt deine Social-Kanäle.

Markaestro ist dafür gebaut, von Software bedient zu werden. Ein MCP-Client wie Claude Code meldet sich über den Browser an und erhält einen Schlüssel, der an eine Marke gebunden ist; jeder andere Agent bekommt denselben Schlüssel aus den Einstellungen. In beiden Fällen kann der Agent herausfinden, auf welche Konten er posten darf, Medien hochladen, Beiträge entwerfen und planen, sie veröffentlichen und melden, was tatsächlich rausging, auf Facebook, Instagram, TikTok, LinkedIn, Threads und Pinterest.

Kein SDK zu installieren, keine Plattform-Zugangsdaten zu pflegen. Dein Team verbindet die Konten einmal im Dashboard; ab dann spricht der Agent mit einer einzigen Bearer-Token-API.

Für Autonomie entwickelt, bewusst begrenzt

Warum ein API-Schlüssel die gesamte Integration ist

Das Schwierige daran, einen Agenten Social Media anfassen zu lassen, ist nicht das HTTP. Es geht darum sicherzustellen, dass ein verwirrtes Modell nicht auf der falschen Marke postet, bei einem Wiederholungsversuch doppelt postet oder etwas veröffentlicht, das niemand gelesen hat. Diese Garantien liegen in der API-Oberfläche selbst, nicht in deinem Prompt.

Ein Schlüssel, eine Marke
Jeder API-Schlüssel ist bei der Erstellung an eine einzelne Marke gebunden. Ein Agent mit diesem Schlüssel kann nur diese Marke sehen und dort posten, markenübergreifende Anfragen werden bei der Authentifizierung abgelehnt, nicht nur per Konvention.
Entdeckung statt fest codierter IDs
Der Agent fragt, auf welche Konten er posten kann, und erhält undurchsichtige IDs zurück, die er unverändert weitergeben kann. Keine Seiten-IDs, kein Durchforsten des Business Manager, keine Konfigurationsdatei, die veraltet, wenn eine Verbindung neu verknüpft wird.
Idempotente Schreibvorgänge
Sende bei jeder Erstellung oder Veröffentlichung einen Idempotency-Key. Ein wiederholter Aufruf innerhalb von 24 Stunden gibt die ursprüngliche Antwort erneut zurück, statt einen zweiten Beitrag zu erstellen, der häufigste Fehlerfall bei Agenten.
Ein Mensch bleibt immer im Bilde
Facebook-, Instagram- und TikTok-Beiträge sind grundsätzlich manuell: Dein Agent bereitet sie vor, ein Mensch postet sie nativ. Nichts geht unbeaufsichtigt raus, es sei denn, du aktivierst das explizit für diesen Beitrag.

MCP-Clients

Anmeldung direkt aus dem Client. Nichts zum Einfügen.

Claude Code, Claude, Cursor, ChatGPT, Grok, Grok Bot, OpenClaw, Hermes und jeder andere Client, der das Model Context Protocol spricht, kann sich ohne konfigurierte Zugangsdaten mit dem gehosteten MCP-Server von Markaestro verbinden. Der erste Tool-Aufruf öffnet deinen Browser: anmelden, Arbeitsbereich und Marke wählen, für die der Agent handeln darf, Berechtigungen prüfen und auf Erlauben klicken. Der Client erhält einen an diese Marke gebundenen Schlüssel und erneuert ihn selbstständig.

Das ist Standard-OAuth 2.1 mit PKCE und dynamischer Client-Registrierung, derselbe Mechanismus wie bei anderen gehosteten MCP-Servern, und funktioniert daher ohne Markaestro-spezifisches Plugin. Der Server läuft unter https://markaestro.com/api/public/v1/mcp und stellt einunddreißig Tools über die öffentliche API bereit: Marken- und Ziel-Erkennung, Medien-Upload, Entwürfe und geplante Beiträge, Veröffentlichung mit Job-Run-Abfrage, Massenoperationen, Webhooks und die Regeln je Kanal.

Agenten verbinden

Wähle deinen Agenten. Drei Schritte, dann kann er posten.

Jeder Client unten erreicht denselben gehosteten MCP-Server. Die meisten melden sich über den Browser an: Der erste Tool-Aufruf öffnet eine Zustimmungsseite, auf der du den Workspace und die Marke wählst, für die der Agent handeln darf, und der Client erhält einen Schlüssel, der an diese Marke gebunden ist. Clients ohne Browser verwenden stattdessen einen Workspace-API-Schlüssel. Gleicher Server, gleiche Berechtigungen, gleiche Liste in den Einstellungen.

Claude Code

Das Plugin installiert Skill und gehosteten Server zusammen. Nichts zu konfigurieren, nichts einzufügen.

Anmeldung oder API-SchlüsselClaude Code-Doku
01

Bevor du beginnst

  • Du bist Workspace-Inhaber oder -Admin mit bestätigter E-Mail, in einem Workspace mit aktivem Plan und mindestens einer Marke.
  • Claude Code ist installiert und bei deinem Anthropic-Konto angemeldet.
03

Anmelden

  1. Frag Claude etwas zu Markaestro, oder führe /mcp aus und wähle markaestro.
  2. Dein Browser öffnet die Zustimmungsseite. Wähle Workspace und Marke, prüfe die Berechtigungen, klicke auf Erlauben.
  3. Um später die Marke zu wechseln, führe /mcp erneut aus, melde dich ab und mit der anderen Marke wieder an.
Bevorzuge die Anmeldung. Nutze einen Schlüssel nur, wenn der Client keinen Browser öffnen kann.
04

Prüfen

  • Bitte den Agenten, list_products aufzurufen. Er sollte mit der einen freigegebenen Marke und ihren verbundenen Kanälen antworten.
  • Die Verbindung erscheint unter Einstellungen, API mit dem Badge Verbundener Agent, der letzten Nutzung und dem Anfragevolumen. Dort kannst du sie jederzeit widerrufen.
Einstellungen, API öffnen
02

Server hinzufügen

  1. Führe die beiden Plugin-Befehle in einem Terminal aus, oder füge mit dem dritten Befehl nur den Server hinzu.
Bash
# The plugin bundles the skill and the hosted server.
claude plugin marketplace add D3vBaba/Markaestro
claude plugin install markaestro@markaestro

# Or add just the server. No key, no header: the first call opens the browser.
claude mcp add --transport http markaestro https://markaestro.com/api/public/v1/mcp

Was passiert, wenn sich der Client verbindet

Fünf Schritte, alle vom Client und vom Browser erledigt. Du siehst nur die Zustimmungsseite.

01Aufforderung
POST /api/public/v1/mcp → 401 + WWW-Authenticate

Der Client ruft den MCP-Endpunkt ohne Zugangsdaten auf. Markaestro antwortet mit 401 und einem WWW-Authenticate-Header, der das Metadaten-Dokument der geschützten Ressource benennt. Dieser Header sagt dem Client, dass eine Anmeldung verfügbar ist.

02Discovery
GET /.well-known/oauth-protected-resource · /.well-known/oauth-authorization-server

Der Client liest zwei öffentliche Dokumente: welcher Autorisierungsserver den Endpunkt schützt und wo dessen Registrierungs-, Autorisierungs- und Token-Endpunkte liegen. Beide werden auf markaestro.com ausgeliefert und sind cachebar.

03Registrierung
POST /api/public/v1/oauth/register

Der Client registriert sich mit einem Namen und seiner Callback-Adresse. Loopback-Adressen, https-Callbacks und native App-Schemata werden akzeptiert; reines http zu einem echten Host wird abgelehnt. Eine vorab geteilte Client-ID ist nicht nötig.

04Zustimmung
GET /oauth/authorize (browser)

Dein Browser öffnet die Zustimmungsseite. Ein Inhaber oder Admin des Arbeitsbereichs mit bestätigter E-Mail wählt Arbeitsbereich und Marke, passt die Berechtigungen an und klickt auf Erlauben. Markaestro schickt den Browser mit einem einmaligen Code zurück zum Client.

05Zugriffstoken
POST /api/public/v1/oauth/token

Der Client tauscht den Code plus seinen PKCE-Verifier gegen ein Access-Token und ein Refresh-Token. Das Access-Token ist ein gewöhnlicher Workspace-API-Schlüssel, gebunden an die gewählte Marke. Es läuft nach 30 Tagen ab; ein Refresh rotiert das Geheimnis und verlängert um weitere 30 Tage.

Das Token ist ein echter API-Schlüssel

Scopes, Markenbindung, Rate-Limits, Abo-Prüfungen, Idempotenz und Widerruf laufen über denselben Codepfad wie ein manuell erstellter Schlüssel. Es gibt kein zweites Berechtigungsmodell.

In den Einstellungen sichtbar und widerrufbar

Ein verbundener Agent erscheint unter Einstellungen, API mit dem Badge Verbundener Agent, seiner letzten Nutzung und seinem Anfragevolumen. Widerrufe ihn dort und der nächste Aufruf des Clients schlägt fehl; der Client kann sein Token beim Trennen auch selbst widerrufen.

Eine Verbindung, eine Marke

Jede Verbindung ist an genau eine Marke gebunden, gewählt bei der Zustimmung. Soll ein Agent an einer zweiten Marke arbeiten, verbinde ihn erneut und wähle diese Marke. Ein Client erreicht nie eine Marke, die ihm nicht gewährt wurde.

Codes und Refresh-Tokens sind einmalig

Autorisierungscodes gelten zehn Minuten und werden atomar verbraucht, ein wiederholter Code schlägt fehl. Refresh-Tokens werden bei jeder Nutzung rotiert und gehasht gespeichert. Inaktive Client-Registrierungen verfallen nach 180 Tagen.

Endpunkte

Für alle, die einen MCP-Client bauen oder den Ablauf prüfen. Alles ist über die beiden Well-known-Dokumente auffindbar; nichts davon muss von Hand konfiguriert werden.

Referenz
# Discovery (public, cacheable)
GET  /.well-known/oauth-protected-resource            RFC 9728
GET  /.well-known/oauth-authorization-server          RFC 8414

# Authorization server
POST /api/public/v1/oauth/register                    RFC 7591, public clients (PKCE) or client_secret
GET  /oauth/authorize?response_type=code&client_id=…&redirect_uri=…
                     &code_challenge=…&code_challenge_method=S256&state=…
POST /api/public/v1/oauth/token                       grant_type=authorization_code | refresh_token
POST /api/public/v1/oauth/revoke                      RFC 7009

# Token response
{ "access_token": "mk_live_<ws>.<client>.<secret>", "token_type": "Bearer",
  "expires_in": 2592000, "refresh_token": "…", "scope": "products.read posts.write …" }

Der Agenten-Kreislauf

Fünf Aufrufe, von Anfang bis Ende

Jede Markaestro-Automatisierung ist eine Variation dieses Kreislaufs. Schritte eins bis drei sind die Connect-API, die flache Oberfläche, auf die die meisten Agenten abzielen sollten. Schritte vier und fünf greifen auf die vollständige /api/public/v1-API für explizite Veröffentlichung und Laufverfolgung zu.

01Entdecken
GET /api/connect/v1/social-accounts

Gibt jedes verbundene, veröffentlichungsfähige Konto für die Marke des Schlüssels zurück, jeweils mit Plattform, Nutzername und undurchsichtiger ID. Rufe es zu Beginn jedes Laufs auf: Verbindungen ändern sich.

02Medien hochladen
POST /api/connect/v1/media/create-upload-url → PUT

Erstelle eine kurzlebige, einmal verwendbare signierte URL und sende dann die rohen Bytes per PUT dorthin. Du erhältst eine Medien-ID zurück. Bilder bis zu 10 MB; die vollständige API nimmt auch Videos bis zu 250 MB.

03Entwerfen oder planen
POST /api/connect/v1/posts

Übergib den Text, die Medien-IDs und die Konto-IDs unverändert. Lass es als Entwurf zur Prüfung, oder sende is_draft false mit scheduled_at, um es in den Kalender einzutragen.

04Veröffentlichen
POST /api/public/v1/posts/:id/publish

Reiht einen asynchronen Lauf ein. LinkedIn, Threads und Pinterest gehen über die offizielle API raus. Facebook, Instagram und TikTok landen in der „Zu veröffentlichen“-Warteschlange des Arbeitsbereichs, damit ein Mensch nativ postet.

05Zurückmelden
GET /api/public/v1/job-runs/:id · webhooks

Frage die Lauf-ID ab, oder registriere einen Webhook-Endpunkt und lass Markaestro post.published, post.action_required und post.failed an dich senden. Nimm nie an, dass eine Veröffentlichung synchron abgeschlossen wurde.

Schnellstart

Eine funktionierende Integration in vier Befehlen

Erstelle zuerst den Schlüssel: Öffne Einstellungen → API, wähle die Marke aus, auf die er zugreifen darf, hake die benötigten Berechtigungen ab und gib optional ein Ablaufdatum an. Der Schlüssel wird einmalig angezeigt, leg ihn direkt in den Secret-Speicher deines Agenten. Das Erstellen von Schlüsseln erfordert einen Administrator oder Inhaber mit verifizierter E-Mail-Adresse.

1. Konten entdecken
Der erste Aufruf in jedem Lauf. Verbindungen ändern sich; IDs sollten nie fest in einen Prompt eingebacken werden.
Bash
# The API is served from the marketing apex and the app subdomain alike.
export MARKAESTRO_URL="https://markaestro.com"
export MARKAESTRO_API_KEY="mk_live_<workspaceId>.<clientId>.<secret>"

# 1. What can this key post to?
curl -s "$MARKAESTRO_URL/api/connect/v1/social-accounts" \
  -H "Authorization: Bearer $MARKAESTRO_API_KEY"
Antwort
{
  "data": [
    {
      "id": "prod_123#instagram:instagram:ig_123",
      "product_id": "prod_123",
      "product": "Northwind Coffee",
      "platform": "instagram",
      "username": "northwindcoffee"
    }
  ]
}
2. Medien hochladen
Zwei Schritte: Erstelle eine signierte, einmal verwendbare URL, sende dann die Bytes per PUT. Die URL läuft nach 15 Minuten ab und benötigt keinen eigenen Auth-Header.
Bash
# 2. Mint a signed upload url, then PUT the bytes.
RESP=$(curl -s -X POST "$MARKAESTRO_URL/api/connect/v1/media/create-upload-url" \
  -H "Authorization: Bearer $MARKAESTRO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "mime_type": "image/png", "size_bytes": 184320, "name": "cold-brew.png" }')
# → { "media_id": "ast_777", "upload_url": "https://.../media/upload?token=..." }

curl -X PUT "<upload_url>" \
  -H "Content-Type: image/png" \
  --data-binary @cold-brew.png
3. Planen, dann beobachten
Das Erstellen ist standardmäßig entwurfsbasiert. Sende is_draft: false mit einem scheduled_at-Zeitstempel, um den Beitrag stattdessen in den Kalender einzutragen.
Bash
# 3. Put it on the calendar. Pass the account id back verbatim.
curl -X POST "$MARKAESTRO_URL/api/connect/v1/posts" \
  -H "Authorization: Bearer $MARKAESTRO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "caption": "Cold brew season starts Friday.",
    "media": ["ast_777"],
    "social_accounts": ["prod_123#instagram:instagram:ig_123"],
    "is_draft": false,
    "scheduled_at": "2026-08-14T15:00:00.000Z"
  }'

# 4. Check where everything stands.
curl -s "$MARKAESTRO_URL/api/connect/v1/posts?limit=20" \
  -H "Authorization: Bearer $MARKAESTRO_API_KEY"

Sofort einsatzbereit

Tool-Definitionen und eine Agenten-Kurzübersicht

Zwei Dinge zum Kopieren. Das erste ist eine Reihe von Tool-Schemas, die den gesamten Veröffentlichungskreislauf abdecken, geschrieben in JSON Schema, sodass sie als Claude-Tool-Definitionen, OpenAI-Funktionen oder als Eingabeform für einen selbst gehosteten MCP-Server funktionieren. Das zweite ist die Betriebs-Kurzübersicht, die verhindert, dass ein Modell damit etwas Unerwartetes tut.

Tool-Schemas
Sechs Tools: Konten auflisten, Medien hochladen, erstellen, veröffentlichen, auflisten, löschen. Verbinde jedes mit dem passenden Endpunkt oben.
tools.json
[
  {
    "name": "markaestro_list_accounts",
    "description": "List the social accounts this Markaestro key can publish to. Call this first in every run. Never hardcode account ids. Returns id, platform, and username.",
    "input_schema": { "type": "object", "properties": {}, "required": [] }
  },
  {
    "name": "markaestro_upload_media",
    "description": "Upload one image or video to Markaestro and return a media asset id. Images: png, jpeg, webp, gif up to 10 MB. Video: mp4, mov, webm up to 250 MB.",
    "input_schema": {
      "type": "object",
      "properties": {
        "file_path": { "type": "string", "description": "Local path to the file to upload." },
        "mime_type": { "type": "string", "description": "MIME type of the file." }
      },
      "required": ["file_path", "mime_type"]
    }
  },
  {
    "name": "markaestro_create_post",
    "description": "Create a post for one channel. Facebook, Instagram, and TikTok are manual-first: a human posts them natively from the To Post queue. Omit delivery_mode unless the user explicitly asked for unattended publishing.",
    "input_schema": {
      "type": "object",
      "properties": {
        "channel": {
          "type": "string",
          "enum": ["facebook", "instagram", "tiktok", "linkedin", "threads", "pinterest", "x"]
        },
        "caption": { "type": "string", "description": "Caption text, max 4000 characters." },
        "media_asset_ids": {
          "type": "array",
          "items": { "type": "string" },
          "description": "Ids from markaestro_upload_media. Instagram and TikTok require at least one."
        },
        "destination_id": {
          "type": "string",
          "description": "From markaestro_list_accounts. Required only when the brand has more than one destination on that channel."
        },
        "delivery_mode": {
          "type": "string",
          "enum": ["manual_reminder", "direct_publish", "platform_inbox"],
          "description": "Omit for the channel default."
        }
      },
      "required": ["channel", "caption"]
    }
  },
  {
    "name": "markaestro_publish_post",
    "description": "Queue an async publish run for an existing post. Returns a run id. Poll it, do not assume the post is live.",
    "input_schema": {
      "type": "object",
      "properties": { "post_id": { "type": "string" } },
      "required": ["post_id"]
    }
  },
  {
    "name": "markaestro_list_posts",
    "description": "List posts for this brand, newest first. Filter by status: draft, scheduled, publishing, published, platform_action_required, failed, partial_failed.",
    "input_schema": {
      "type": "object",
      "properties": {
        "status": { "type": "string" },
        "limit": { "type": "integer", "minimum": 1, "maximum": 100 }
      },
      "required": []
    }
  },
  {
    "name": "markaestro_delete_post",
    "description": "Remove a post from Markaestro. Use it to cancel something scheduled. Deleting an already-published post does NOT retract the live copy on the platform.",
    "input_schema": {
      "type": "object",
      "properties": { "post_id": { "type": "string" } },
      "required": ["post_id"]
    }
  }
]
Agenten-Kurzübersicht
In deinen System-Prompt einfügen. Sie kodiert die Verhaltensweisen, die einen zuverlässigen Veröffentlichungsagenten von einem unterscheiden, der doppelt postet und zu früh Erfolg meldet.
System-Prompt
You have a Markaestro API key for exactly one brand. Markaestro is the
publishing layer: you supply the caption and the media, it handles the
platform rules, the calendar, and delivery.

Base URL: https://markaestro.com
Auth: Authorization: Bearer $MARKAESTRO_API_KEY

Rules:
- Call GET /api/connect/v1/social-accounts before posting. Pass the returned
  account ids back verbatim. Never invent or cache an id across runs.
- Upload media before creating a post; posts reference media ids, not files.
- Facebook, Instagram, and TikTok are manual-first. Creating and publishing
  them queues a reminder for a human. That is the intended behavior. Only
  send deliveryMode "direct_publish" if the operator explicitly asked for it.
- Send a unique Idempotency-Key on every POST. Reuse the SAME key when
  retrying the SAME request; never reuse it for a different one.
- On 429, wait the number of seconds in Retry-After, then retry. On 4xx other
  than 429, do not retry. Report the error code and requestId and stop.
- Publishing is async. POST /publish returns a run id; poll
  GET /api/public/v1/job-runs/<id> until succeeded or failed.
- To cancel, list with ?status=scheduled and DELETE the post id. Deleting a
  published post does not remove it from the platform.
- Never claim a post is live until a run reports succeeded or a post reports
  published.

Dein Agent kann dies auch selbst abrufen: curl https://markaestro.com/llms.txt gibt eine Klartext-Kurzübersicht der gesamten API zurück, Endpunkte, Regeln und Fehlerbehandlung, kompakt genug, um in den Kontext zu passen.

Rezepte

Die vier Workflows, die Agenten tatsächlich nutzen

Veröffentlichen und bestätigen
Erstelle einen Entwurf, veröffentliche ihn explizit und frage dann den Lauf ab. Der einzig ehrliche Weg, dem Betreiber zu sagen, dass ein Beitrag rausgegangen ist.
Bash
# Full control: draft → publish → poll. No productId needed:
# the key is already bound to one brand.

POST_ID=$(curl -s -X POST "$MARKAESTRO_URL/api/public/v1/posts" \
  -H "Authorization: Bearer $MARKAESTRO_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: post-2026-08-14-linkedin" \
  -d '{
    "channel": "linkedin",
    "caption": "We shipped agent-driven publishing.",
    "mediaAssetIds": ["ast_777"]
  }' | jq -r .post.id)

RUN_ID=$(curl -s -X POST "$MARKAESTRO_URL/api/public/v1/posts/$POST_ID/publish" \
  -H "Authorization: Bearer $MARKAESTRO_API_KEY" \
  -H "Idempotency-Key: publish-$POST_ID" | jq -r .run.id)

# queued → running → succeeded | failed
curl -s "$MARKAESTRO_URL/api/public/v1/job-runs/$RUN_ID" \
  -H "Authorization: Bearer $MARKAESTRO_API_KEY"
Warteschlange prüfen und abbrechen
Liste auf, was geplant ist, zeig es einem Menschen, lösche, was abgelehnt wird. Beide Aufrufe nutzen Berechtigungen, die ein bestehender Schlüssel bereits hat.
Bash
# Review the queue, then cancel what the operator rejected.
curl -s "$MARKAESTRO_URL/api/public/v1/posts?status=scheduled&limit=100" \
  -H "Authorization: Bearer $MARKAESTRO_API_KEY"

curl -X DELETE "$MARKAESTRO_URL/api/public/v1/posts/pst_123" \
  -H "Authorization: Bearer $MARKAESTRO_API_KEY"
# → { "deleted": true, "id": "pst_123" }
Eine Woche in einem Aufruf füllen
Die Batch-Erstellung nimmt bis zu 25 Beiträge entgegen und gibt Ergebnisse pro Element zurück, sodass ein einzelnes fehlerhaftes Element nicht den gesamten Lauf zum Scheitern bringt.
Bash
# One call, up to 25 posts. Per-item results: one bad item
# does not fail the batch.
curl -X POST "$MARKAESTRO_URL/api/public/v1/posts" \
  -H "Authorization: Bearer $MARKAESTRO_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: week-33-drop" \
  -d '{
    "posts": [
      { "channel": "instagram", "caption": "Monday",  "mediaAssetIds": ["ast_1"] },
      { "channel": "facebook",  "caption": "Tuesday", "mediaAssetIds": ["ast_2"] },
      { "channel": "linkedin",  "caption": "Thursday" }
    ]
  }'
# → { "results": [...], "created": 3, "total": 3 }
Angerufen werden statt abzufragen
Langlebige Agenten sollten einen Webhook registrieren und warten. Zustellungen sind HMAC-signiert mit einem Secret, das einmalig bei der Erstellung angezeigt wird.
Bash
# Let Markaestro call you instead of polling.
curl -X POST "$MARKAESTRO_URL/api/public/v1/webhook-endpoints" \
  -H "Authorization: Bearer $MARKAESTRO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-agent.example.com/hooks/markaestro",
    "events": ["post.published", "post.action_required", "post.failed"]
  }'

# Each delivery carries:
#   X-Markaestro-Event      post.action_required
#   X-Markaestro-Timestamp  2026-08-14T15:00:04.000Z
#   X-Markaestro-Signature  HMAC of the body with your webhook secret
# The secret is shown once at creation and stored hashed. Verify before acting.

Schutzmechanismen

Was der Agent darf und nicht darf

Autonomie ist nur nützlich, wenn der Wirkungsradius klein ist. Die Standardeinstellungen von Markaestro gehen davon aus, dass der Aufrufer Software ist, die sich irren könnte.

Facebook, Instagram und TikTok sind grundsätzlich manuell

Beiträge, die dein Agent für diese Kanäle erstellt, nutzen standardmäßig manual_reminder: Markaestro ruft niemals die API der Plattform für sie auf. Das Veröffentlichen verschiebt den Beitrag in die „Zu veröffentlichen“-Warteschlange des Arbeitsbereichs, wo eine Person die Medien herunterlädt, nativ postet und bestätigt, sodass der Beitrag genau so aussieht, als wäre er von Hand erstellt worden, und ein Mensch jeden einzelnen sieht, bevor er öffentlich existiert. Ein Agent kann einen einzelnen Beitrag für die offizielle API-Veröffentlichung mit deliveryMode: "direct_publish" aktivieren, und bei TikTok bedeutet das die Posteingangsübergabe an den Creator, niemals einen unbeaufsichtigten öffentlichen Beitrag. LinkedIn, Threads und Pinterest veröffentlichen programmatisch, sobald dein Agent explizit danach fragt.

Schlüsselberechtigungen einschränken

Wähle nur die Berechtigungen, die der Agent braucht: products.read, media.write, posts.read, posts.write, posts.publish, job_runs.read, webhooks.manage. Ein Recherche-Agent, der nur den Kalender liest, erhält posts.read und nichts weiter.

Ein Ablaufdatum geben

Schlüssel können mit einem Ablaufdatum erstellt werden. Ein abgelaufener Schlüssel verhält sich genau wie ein widerrufener, sodass ein Schlüssel, der aus der Umgebung eines Agenten austritt, von selbst aufhört zu funktionieren.

Rotieren und widerrufen

Rotiere einen Schlüssel an Ort und Stelle oder widerrufe ihn direkt unter Einstellungen → API. Jeder Schlüssel zeigt seine letzte Nutzung und sein Anfragevolumen, sodass ein Agent, der still wird, oder außer Kontrolle gerät, sichtbar bleibt.

Ratenlimits werden durchgesetzt

60 Anfragen pro Minute pro Endpunkt und 240 pro Minute pro Schlüssel. Jede Antwort trägt X-RateLimit-Limit, -Remaining und -Reset; ein 429 trägt Retry-After. Beachte es, statt hartnäckig weiterzumachen.

Markaestro schreibt niemals für dich

Es gibt keinen Generierungsschritt. Der Text kommt von deinem Agenten, die Medien kommen aus deiner Bibliothek oder der Pipeline deines Agenten. Markaestro liefert die Hände, nicht die Stimme.

Löschungen erfolgen auf Markaestro-Seite

Das Löschen eines geplanten Beitrags bricht ihn ab, bevor er live geht. Das Löschen eines bereits veröffentlichten Beitrags stoppt nur die Nachverfolgung durch Markaestro, der aktive Beitrag bleibt online, bis ihn jemand auf der Plattform entfernt.

Fehlerbehandlung

Bring ihm bei, welche Fehler eine Wiederholung wert sind

Jede Fehlerantwort ist JSON mit einem stabilen error-Code und einer requestId. Lass deinen Agenten die requestId zitieren, wenn er einen Fehler meldet, das braucht der Support, um den Aufruf nachzuverfolgen.

StatusCodeWas der Agent tun sollte
401UNAUTHENTICATEDDer Schlüssel fehlt, wurde widerrufen oder ist abgelaufen. Stoppe und bitte einen Menschen um einen neuen, ein Wiederholungsversuch hilft nicht.
403FORBIDDENDem Schlüssel fehlt die Berechtigung für diesen Aufruf. Melde, welcher Aufruf fehlgeschlagen ist; Berechtigungen werden unter Einstellungen → API geändert.
403API_KEY_NOT_BOUND_TO_PRODUCTEin Schlüssel, der vor der Markenbindung ausgestellt wurde. Bitte um einen Ersatzschlüssel.
400VALIDATION_*Die Nutzdaten haben eine Kanalregel verletzt (fehlende Medien, ungültiger Zustellmodus, falsches scheduled_at). Korrigiere die Anfrage; wiederhole sie nicht unverändert.
400VALIDATION_IDEMPOTENCY_KEY_REUSEDDerselbe Idempotency-Key wurde mit einem anderen Body gesendet. Erstelle einen neuen Schlüssel für jede eigenständige Anfrage.
400VALIDATION_POST_IS_PUBLISHINGEs wurde versucht, einen Beitrag zu löschen, während ein Veröffentlichungslauf lief. Warte, bis er sich erledigt hat, und lösche dann.
409VALIDATION_POST_ALREADY_PUBLISHINGFür diesen Beitrag ist bereits ein Veröffentlichungslauf eingereiht. Veröffentliche nicht erneut, frage den bestehenden Lauf ab.
402SUBSCRIPTION_REQUIREDDiesem Workspace ist kein aktiver Tarif zugeordnet. Bitte einen Workspace-Inhaber, die Abrechnung in den Einstellungen zu prüfen.
402QUOTA_EXCEEDED_MEDIA_UPLOADSDer Arbeitsbereich hat sein monatliches Upload-Kontingent erreicht. Stoppe das Hochladen und weise darauf hin, vorhandene Medien werden weiterhin veröffentlicht.
404NOT_FOUNDDie ID liegt außerhalb der Marke dieses Schlüssels. Wird als 404 statt 403 beantwortet, damit Schlüssel nicht nach IDs suchen können, die ihnen nicht gehören.
429RATE_LIMITEDWarte die in Retry-After angegebene Anzahl Sekunden und wiederhole dieselbe Anfrage mit demselben Idempotency-Key.

Bring deinen eigenen Stack mit

Wenn es eine HTTPS-Anfrage stellen kann, kann es veröffentlichen

Es gibt keine Markaestro-Client-Bibliothek zu übernehmen und kein Framework, an das man sich halten müsste. Bearer-Token, JSON rein, JSON raus.

Claude & das Claude Agent SDK

Füge die obigen Tool-Definitionen zu deiner Tool-Liste hinzu. Die JSON-Schema-Formen liegen bereits im Claude-Tool-Use-Format vor.

OpenAI-Funktionsaufruf

Dieselben Schemas lassen sich eins zu eins auf Funktionsdefinitionen übertragen, input_schema wird einfach zu parameters umbenannt.

MCP-Clients

Claude Code, Claude, Cursor, ChatGPT, Grok, Grok Bot, OpenClaw, Hermes: die URL des gehosteten Servers hinzufügen und über den Browser anmelden. Für reine stdio-Clients führt npx -y @markaestro/mcp dieselben einunddreißig Tools lokal aus.

n8n, Make, Zapier

Jeder Endpunkt ist eine einfache HTTP-Anfrage mit einem Bearer-Token. Kein SDK, keine Signierzeremonie, kein OAuth-Tanz für den Agenten.

LangChain & LlamaIndex

Standard-REST-Tools. Der zweistufige Medien-Upload ist der einzige Ablauf mit mehreren Aufrufen, und er umfasst nur zwei Zeilen.

Ein Cronjob und curl

Nicht jeder Agent braucht ein Framework. Der obige Schnellstart ist eine vollständige, funktionierende Integration in vier Befehlen.

Gib deinem Agenten etwas Echtes zu tun

Verbinde deine Kanäle, dann deinen Agenten: Anmeldung aus einem MCP-Client oder ein markengebundener Schlüssel. Beides ist die gesamte Integration.