Chikaboom/Chikaboom
← Chikaboom
✦ AI AGENT INTEGRATION

Chikaboom for AI agents

Chikaboom exposes its rendering and scheduling tools via MCP (Model Context Protocol). Any MCP-compatible AI client can authenticate with an API key and call Chikaboom tools on behalf of the user.

What this integration does

When you connect an external AI agent to Chikaboom, your AI assistant gains the ability to:

  • List your brands and discover what templates are available
  • Render on-brand social posts (single, batch, or multi-slide carousel)
  • Schedule rendered posts to your content calendar for automatic publishing
  • Read your scheduled posts to avoid double-booking

The agent works against the same brand templates a designer built for you — so output is always on-brand. The agent can't draw shapes or change visual identity; it can only fill in the text fields your designer exposed.

Quick start: Claude Desktop

  1. Generate an API key. Sign in to Chikaboom, open Settings, click Create new key. Copy the token (bs_live_…) — it's only shown once.
  2. Edit your Claude Desktop config. On macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
    {
  "mcpServers": {
    "chikaboom": {
      "url": "https://<your-chikaboom-domain>/api/mcp",
      "headers": {
        "Authorization": "Bearer bs_live_YOUR_TOKEN"
      }
    }
  }
}
  3. Restart Claude Desktop. Chikaboom's tools now appear in Claude's tool list.
  4. Ask in natural language. Try: "Render a LinkedIn post for our latest product launch and schedule it for Friday 9am." The agent calls Chikaboom tools and returns clickable preview URLs.

Tool reference

Chikaboom exposes the following tools via MCP:

list_brands

Find which brands the authenticated user has access to.

Input(no parameters)
OutputArray of { brand_id, brand_name, role, templates_count }
list_templates

List templates in a brand, including each template's field schema (so the agent knows what keys it can fill).

Input{ brand_id: string }
OutputArray of { template_id, name, category, width, height, fields[] }
render_post

Render a single post to PNG. Returns a public URL.

Input{ brand_id, template_id, content: Record<string,string>, format_id? }
Output{ url, template_id, template_name, width, height, duration_ms }
render_batch

Render many posts in one call. Returns a ZIP URL.

Input{ brand_id, template_id, rows: Array<Record<string,string>> }
Output{ zip_url, total, succeeded, failed, failures[] }
render_carousel

Render a multi-slide carousel as PDF for LinkedIn document posts. Returns PDF URL plus a cover-slide PNG for previews.

Input{ brand_id, slides: Array<{template_id, content}>, title? }
Output{ pdf_url, cover_url, slides_count }
schedule_post

Create a scheduled post in the user's content calendar. Optionally pre-render the asset, or schedule as draft.

Input{ brand_id, template_id, content, scheduled_for (ISO 8601), caption?, platforms?, asset_url? }
Output{ post_id, status, scheduled_for, calendar_url }
list_scheduled_posts

Read the user's calendar in a date range. Useful before scheduling to avoid double-posting.

Input{ brand_id, from?, to? }
Output{ posts[], count }
ask_user

Client-side tool — present clickable options to the user. The agent uses this when the answer is one of a small set (which brand, which template, what time, etc.).

Input{ question, options: string[2..6], allow_other? }
Output(user's chosen text comes back as the next user message)

Protocol details

Chikaboom implements MCP version 2024-11-05 over JSON-RPC 2.0 at POST /api/mcp.

Supported methods:

  • initialize — handshake, returns protocol version + server info
  • tools/list — list available tool definitions
  • tools/call — invoke a tool with arguments
  • notifications/initialized — no-op acknowledgment (returns 204)

Errors follow standard JSON-RPC 2.0 codes. Authentication failures return -32000 with a clear message; missing methods return -32601.

Frequently asked

What protocol does Chikaboom's AI integration use?

MCP — Model Context Protocol. Chikaboom implements a JSON-RPC 2.0 server at POST /api/mcp that speaks the standard MCP methods: initialize, tools/list, tools/call.

Which AI clients can connect to Chikaboom?

Any MCP-compatible client. Confirmed working: Claude Desktop. Should also work with Cursor, custom agents built on the Anthropic SDK, and other MCP clients as they adopt the standard.

How does authentication work for AI agents?

API keys. Each user generates one or more keys in their Settings page. Keys are scoped to that user's brand access. Send as Authorization: Bearer <key>. Keys can be revoked at any time and last-used time is logged.

Can an AI agent publish to LinkedIn/Twitter directly through Chikaboom?

Indirectly. The agent calls schedule_post to put a post on the calendar. The Chikaboom cron worker then publishes to connected platforms at the scheduled time. The agent itself never touches platform APIs.

Are there rate limits on the MCP endpoint?

Each render takes roughly 200-400ms depending on template complexity. There's no hard rate limit currently; abuse triggers automatic key suspension. Batch tool reduces overhead for bulk operations.

Ready to connect?

Sign in, create an API key in Settings, and your AI client gets on-brand rendering as a native capability.

Sign in & create a key →