MarkaestroMarkaestro

Para agentes de IA

Conecte seu agente em um passo. Ele cuida dos seus canais sociais.

O Markaestro foi feito para ser operado por software. Um cliente MCP como o Claude Code faz login pelo navegador e recebe uma chave vinculada a uma única marca; qualquer outro agente obtém a mesma chave nas Configurações. Nos dois casos o agente consegue descobrir em quais contas pode publicar, enviar mídia, redigir e agendar posts, publicá-los e reportar o que realmente saiu, no Facebook, Instagram, TikTok, LinkedIn, Threads e Pinterest.

Nenhum SDK para instalar e nenhuma credencial de plataforma para vigiar. Sua equipe conecta as contas uma vez no painel; a partir daí o agente fala com uma única API de token bearer.

Projetado para autonomia, limitado por propósito

Por que uma chave de API é toda a integração

A parte difícil de deixar um agente lidar com mídia social não é o HTTP. É garantir que um modelo confuso não publique na marca errada, publique em duplicidade em uma nova tentativa, ou envie algo que ninguém revisou. Essas garantias estão na própria superfície da API, não no seu prompt.

Uma chave, uma marca
Toda chave de API é vinculada a uma única marca quando você a cria. Um agente com essa chave só pode ver e publicar nessa marca, solicitações entre marcas são rejeitadas na autenticação, não por convenção.
Descoberta, não ids fixos
O agente pergunta em quais contas pode publicar e recebe ids opacos para repassar diretamente. Sem ids de Página, sem vasculhar o Business Manager, sem arquivo de configuração que se torna obsoleto quando uma conexão é refeita.
Gravações idempotentes
Envie um Idempotency-Key em qualquer criação ou publicação. Uma chamada repetida em até 24 horas reproduz a resposta original em vez de criar um segundo post, o modo de falha mais comum entre agentes.
Um humano permanece no processo
Posts do Facebook, Instagram e TikTok são manual-first: seu agente os prepara, uma pessoa os publica nativamente. Nada sai sem supervisão, a menos que você opte explicitamente por isso.

Clientes MCP

Faça login pelo cliente. Nada para colar.

Claude Code, Claude, Cursor, ChatGPT, Grok, Grok Bot, OpenClaw, Hermes e qualquer outro cliente que fale o Model Context Protocol podem se conectar ao servidor MCP hospedado do Markaestro sem nenhuma credencial configurada. A primeira chamada de ferramenta abre seu navegador: faça login, escolha o espaço de trabalho e a marca em que o agente pode atuar, revise as permissões e clique em Permitir. O cliente recebe uma chave vinculada a essa marca e a renova sozinho.

É OAuth 2.1 padrão com PKCE e registro dinâmico de clientes, o mesmo mecanismo por trás de outros servidores MCP hospedados, então funciona sem nenhum plugin específico do Markaestro. O servidor fica em https://markaestro.com/api/public/v1/mcp e expõe trinta e uma ferramentas sobre a API pública: descoberta de marcas e destinos, envio de mídia, rascunhos e posts agendados, publicação com acompanhamento de execuções, operações em lote, webhooks e as regras por canal.

Conecte seu agente

Escolha seu agente. Três passos e ele já pode publicar.

Todos os clientes abaixo chegam ao mesmo servidor MCP hospedado. A maioria entra pelo navegador: a primeira chamada de ferramenta abre uma página de consentimento onde você escolhe o workspace e a marca em que o agente pode atuar, e o cliente recebe uma chave vinculada a essa marca. Clientes que não conseguem abrir um navegador usam uma chave de API do workspace. Mesmo servidor, mesmas permissões, mesma lista em Configurações.

Claude Code

O plugin instala a skill e o servidor hospedado juntos. Nada para configurar, nada para colar.

Login ou chave de APIDocumentação do Claude Code
01

Antes de começar

  • Você é proprietário ou administrador do workspace com e-mail verificado, em um workspace com plano ativo e pelo menos uma marca.
  • O Claude Code está instalado e conectado à sua conta Anthropic.
03

Entrar

  1. Pergunte ao Claude qualquer coisa sobre o Markaestro, ou execute /mcp e escolha markaestro.
  2. Seu navegador abre a página de consentimento. Escolha o workspace e a marca, revise as permissões e clique em Permitir.
  3. Para trocar de marca depois, execute /mcp de novo, saia e entre com a outra marca.
Prefira o login. Use uma chave apenas quando o cliente não puder abrir um navegador.
04

Verificar

  • Peça ao agente para chamar list_products. Ele deve responder com a única marca autorizada e seus canais conectados.
  • A conexão aparece em Configurações, API com o selo Agente conectado, o último uso e o volume de solicitações. Você pode revogá-la ali a qualquer momento.
Abrir Configurações, API
02

Adicionar o servidor

  1. Execute os dois comandos do plugin em qualquer terminal, ou adicione só o servidor com o terceiro comando.
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

O que acontece quando o cliente se conecta

Cinco passos, todos tratados pelo cliente e pelo navegador. Você só vê a página de consentimento.

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

O cliente chama o endpoint MCP sem credencial. O Markaestro responde 401 com um cabeçalho WWW-Authenticate que aponta o documento de metadados do recurso protegido. É esse cabeçalho que avisa o cliente de que há um login disponível.

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

O cliente lê dois documentos públicos: qual servidor de autorização protege o endpoint e onde ficam seus endpoints de registro, autorização e token. Os dois são servidos em markaestro.com e podem ser cacheados.

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

O cliente se registra com um nome e seu endereço de retorno. Endereços loopback, retornos https e esquemas de apps nativos são aceitos; http simples para um host real é recusado. Nenhum id de cliente pré-compartilhado é necessário.

04Consentimento
GET /oauth/authorize (browser)

Seu navegador abre a página de consentimento. Um proprietário ou administrador do espaço de trabalho com e-mail verificado escolhe o espaço e a marca, ajusta as permissões e clica em Permitir. O Markaestro devolve o navegador ao cliente com um código de uso único.

05Token de acesso
POST /api/public/v1/oauth/token

O cliente troca o código mais seu verificador PKCE por um token de acesso e um token de atualização. O token de acesso é uma chave de API comum do espaço de trabalho, vinculada à marca escolhida. Ele expira em 30 dias; uma atualização rotaciona o segredo e o estende por mais 30.

O token é uma chave de API de verdade

Escopos, vínculo à marca, limites de taxa, verificações de assinatura, idempotência e revogação seguem o mesmo código de uma chave criada à mão. Não há um segundo modelo de permissões para entender.

Listado e revogável nas Configurações

Um agente conectado aparece em Configurações, API com o selo Agente conectado, o último uso e o volume de requisições. Revogue-o ali e a próxima chamada do cliente falha; o cliente também pode revogar o próprio token quando você o desconecta.

Uma conexão, uma marca

Cada conexão é vinculada a exatamente uma marca, escolhida no consentimento. Para deixar um agente trabalhar em uma segunda marca, conecte-o de novo e escolha essa marca. Um cliente nunca alcança uma marca que não lhe foi concedida.

Códigos e tokens de atualização de uso único

Os códigos de autorização duram dez minutos e são consumidos de forma atômica, então um código repetido falha. Os tokens de atualização rotacionam a cada uso e são armazenados com hash. Registros de cliente inativos expiram após 180 dias.

Pontos de acesso

Para quem constrói um cliente MCP ou audita o fluxo. Tudo é descoberto a partir dos dois documentos well-known; nada aqui precisa ser configurado à mão.

Referência
# 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 …" }

O ciclo do agente

Cinco chamadas, do início ao fim

Toda automação do Markaestro é uma variação deste ciclo. Os passos um a três são a Connect API, a superfície simples que a maioria dos agentes deve usar. Os passos quatro e cinco acessam a API completa /api/public/v1 para publicação explícita e acompanhamento de execuções.

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

Retorna cada conta conectada e publicável da marca da chave, cada uma com uma plataforma, um nome de usuário e um id opaco. Chame no início de cada execução, as conexões mudam.

02Enviar mídia
POST /api/connect/v1/media/create-upload-url → PUT

Gere uma URL assinada de uso único e curta duração, depois envie os bytes brutos para ela com PUT. Você recebe um id de mídia de volta. Imagens de até 10 MB; a API completa também aceita vídeo de até 250 MB.

03Criar rascunho ou agendar
POST /api/connect/v1/posts

Passe a legenda, os ids de mídia e os ids de conta literalmente. Deixe como rascunho para revisão, ou envie is_draft false com scheduled_at para colocá-lo no calendário.

04Publicar
POST /api/public/v1/posts/:id/publish

Enfileira uma execução assíncrona. LinkedIn, Threads e Pinterest saem pela API oficial. Facebook, Instagram e TikTok entram na fila 'Para Publicar' do workspace para uma pessoa publicar nativamente.

05Reportar de volta
GET /api/public/v1/job-runs/:id · webhooks

Verifique o id da execução, ou registre um endpoint de webhook e deixe o Markaestro enviar post.published, post.action_required e post.failed para você. Nunca assuma que uma publicação terminou de forma síncrona.

Guia Rápido

Uma integração funcional em quatro comandos

Primeiro, gere a chave: abra Configurações → API, escolha a marca que ela pode acessar, marque os escopos necessários e, opcionalmente, defina uma expiração. A chave é exibida apenas uma vez, coloque-a diretamente no armazenamento de segredos do seu agente. Criar chaves exige um administrador ou proprietário com e-mail verificado.

1. Descobrir as contas
A primeira chamada em toda execução. As conexões mudam; os ids nunca devem ficar embutidos em um prompt.
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"
Resposta
{
  "data": [
    {
      "id": "prod_123#instagram:instagram:ig_123",
      "product_id": "prod_123",
      "product": "Northwind Coffee",
      "platform": "instagram",
      "username": "northwindcoffee"
    }
  ]
}
2. Enviar a mídia
Duas etapas: gere uma URL assinada de uso único, depois envie os bytes com PUT. A URL expira após 15 minutos e não precisa de cabeçalho de autenticação próprio.
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. Agende e acompanhe
A criação é rascunho por padrão. Envie is_draft: false com um timestamp scheduled_at para colocar o post no calendário.
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"

Pronto para usar

Definições de ferramentas e um resumo para agentes

Duas coisas para copiar. A primeira é um conjunto de esquemas de ferramentas cobrindo todo o ciclo de publicação, escritos em JSON Schema, então funcionam como definições de ferramentas do Claude, funções da OpenAI, ou o formato de entrada para um servidor MCP que você hospedar. A segunda é o resumo operacional que evita que um modelo faça algo inesperado com elas.

Esquemas de ferramentas
Seis ferramentas: listar contas, enviar mídia, criar, publicar, listar, excluir. Conecte cada uma ao endpoint correspondente acima.
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"]
    }
  }
]
Resumo para agentes
Cole no seu prompt de sistema. Ele codifica os comportamentos que diferenciam um agente de publicação confiável de um que publica em duplicidade e declara vitória antes da hora.
Prompt de sistema
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.

Seu agente também pode buscar isso sozinho: curl https://markaestro.com/llms.txt retorna um resumo em texto simples de toda a API, endpoints, regras e tratamento de erros, pequeno o suficiente para caber no contexto.

Receitas

Os quatro fluxos de trabalho que agentes realmente executam

Publicar e confirmar
Crie um rascunho, publique-o explicitamente, depois verifique a execução. A única forma honesta de dizer ao operador que um post foi ao ar.
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"
Auditar e cancelar a fila
Liste o que está agendado, mostre a um humano, exclua o que for rejeitado. Ambas as chamadas usam escopos que uma chave existente já possui.
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" }
Preencha uma semana em uma chamada
A criação em lote aceita até 25 posts e retorna resultados por item, então um único item malformado não derruba a execução inteira.
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 }
Seja chamado em vez de ficar verificando
Agentes de longa duração devem registrar um webhook e aguardar. As entregas são assinadas com HMAC usando um segredo exibido apenas uma vez na criação.
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.

Salvaguardas

O que o agente pode e não pode fazer

Autonomia só é útil se o raio de impacto for pequeno. Os padrões do Markaestro assumem que quem está chamando é um software que pode estar errado.

Facebook, Instagram e TikTok são manual-first

Posts que seu agente cria para esses canais usam por padrão manual_reminder: o Markaestro nunca chama a API da plataforma para eles. A publicação move o post para a fila 'Para Publicar' do workspace, onde uma pessoa baixa a mídia, publica nativamente e confirma, de modo que o post parece exatamente como se tivesse sido feito manualmente, e um humano vê cada um antes que ele exista publicamente. Um agente pode optar por publicação via API oficial em um único post com deliveryMode: "direct_publish", e no TikTok isso significa o envio para a caixa de entrada do criador, nunca um post público sem supervisão. LinkedIn, Threads e Pinterest publicam programaticamente assim que seu agente solicita explicitamente.

Limite a chave

Escolha apenas os escopos que o agente precisa: products.read, media.write, posts.read, posts.write, posts.publish, job_runs.read, webhooks.manage. Um agente de pesquisa que só lê o calendário recebe posts.read e nada mais.

Defina uma expiração

As chaves podem ser criadas com expiração. Uma chave expirada se comporta exatamente como uma revogada, então uma chave que vaza do ambiente de um agente para de funcionar sozinha.

Rotacione e revogue

Rotacione uma chave no local ou revogue-a completamente em Configurações → API. Cada chave mostra seu último uso e volume de solicitações, então um agente que fica quieto, ou sai do controle, é visível.

Limites de taxa são aplicados

60 solicitações por minuto por endpoint e 240 por minuto por chave. Toda resposta traz X-RateLimit-Limit, -Remaining e -Reset; um 429 traz Retry-After. Respeite-o em vez de insistir.

O Markaestro nunca escreve por você

Não há etapa de geração. A legenda vem do seu agente, a mídia vem da sua biblioteca ou do pipeline do seu agente. O Markaestro são as mãos, não a voz.

Exclusões são do lado do Markaestro

Excluir um post agendado o cancela antes de ir ao ar. Excluir um post publicado apenas para o Markaestro de acompanhá-lo, o post ao vivo permanece até que alguém o remova na plataforma.

Tratamento de falhas

Ensine quais erros valem uma nova tentativa

Toda resposta de erro é JSON com um código error estável e um requestId. Peça ao seu agente para citar o requestId ao reportar uma falha, é o que o suporte precisa para rastrear a chamada.

StatusCódigoO que o agente deve fazer
401UNAUTHENTICATEDA chave está ausente, revogada ou expirada. Pare e peça a um humano uma nova, tentar novamente não ajudará.
403FORBIDDENA chave não tem o escopo para essa chamada. Reporte qual chamada falhou; os escopos são alterados em Configurações → API.
403API_KEY_NOT_BOUND_TO_PRODUCTUma chave emitida antes da vinculação de marca. Peça uma chave substituta.
400VALIDATION_*O payload violou uma regra do canal (mídia ausente, modo de entrega inválido, scheduled_at incorreto). Corrija a solicitação; não tente novamente sem alterá-la.
400VALIDATION_IDEMPOTENCY_KEY_REUSEDO mesmo Idempotency-Key foi enviado com um corpo diferente. Gere uma nova chave para cada solicitação distinta.
400VALIDATION_POST_IS_PUBLISHINGTentativa de excluir um post enquanto uma execução de publicação está em andamento. Aguarde a execução se estabilizar, depois exclua.
409VALIDATION_POST_ALREADY_PUBLISHINGUma execução de publicação para esse post já está na fila. Não publique novamente, verifique a execução existente.
402SUBSCRIPTION_REQUIREDNenhum plano ativo está associado a este workspace. Peça a um proprietário para revisar o faturamento nas Configurações.
402QUOTA_EXCEEDED_MEDIA_UPLOADSO workspace atingiu sua cota mensal de upload. Pare de enviar e informe isso, a mídia existente continua sendo publicada.
404NOT_FOUNDO id está fora da marca dessa chave. Respondido como 404 em vez de 403 para que as chaves não possam sondar ids que não possuem.
429RATE_LIMITEDAguarde os segundos de Retry-After, então tente novamente a mesma solicitação com o mesmo Idempotency-Key.

Use sua própria stack

Se puder fazer uma solicitação HTTPS, pode publicar

Não há biblioteca cliente do Markaestro para adotar nem framework para padronizar. Bearer token, JSON na entrada, JSON na saída.

Claude e o Claude Agent SDK

Adicione as definições de ferramentas acima à sua lista de ferramentas. Os formatos JSON Schema já estão no formato de uso de ferramentas do Claude.

Function calling da OpenAI

Os mesmos esquemas mapeiam diretamente para definições de função, renomeie input_schema para parameters.

Clientes MCP

Claude Code, Claude, Cursor, ChatGPT, Grok, Grok Bot, OpenClaw, Hermes: adicione a URL do servidor hospedado e faça login pelo navegador. Para clientes só stdio, npx -y @markaestro/mcp executa as mesmas trinta e uma ferramentas localmente.

n8n, Make, Zapier

Todo endpoint é uma solicitação HTTP simples com um bearer token. Sem SDK, sem cerimônia de assinatura, sem fluxo OAuth para o agente.

LangChain e LlamaIndex

Ferramentas REST padrão. O upload de mídia em duas etapas é o único fluxo com múltiplas chamadas, e são apenas duas linhas.

Um cron job e curl

Nem todo agente precisa de um framework. O guia rápido acima é uma integração completa e funcional em quatro comandos.

Dê ao seu agente algo real para fazer

Conecte seus canais e depois seu agente: login por um cliente MCP, ou uma chave vinculada a uma marca. Qualquer um dos dois é a integração inteira.