> ## Documentation Index > Fetch the complete documentation index at: https://docs.parallellabs.app/llms.txt > Use this file to discover all available pages before exploring further. # List the company's keywords. > Returns every keyword the company has metrics for - including the ones a research run harvested - sorted by search volume. Pass savedOnly=true to narrow to keywords a user explicitly kept. ## OpenAPI ````yaml /openapi.json get /api/v0/seo/keywords openapi: 3.0.3 info: title: API Documentation version: 1.0.0 description: > # Introduction Welcome to the API. This API provides programmatic access to all platform features including AI agents, smart lists, documents, sequences, and media generation. ## Authentication The API supports two types of authentication: 1. **Company API Keys** - Scoped to a specific company 2. **Personal Access Keys** - User-level keys that work across all your companies --- ### Option 1: Company API Key Company API keys are tied to a specific company. Use this when you only need to access one company. **Getting a Company API Key:** 1. Log in to your dashboard 2. Navigate to **Integrations** page 3. Find the **API Keys** section and click **Generate New Key** 4. Copy and securely store your API key (it won't be shown again) **Usage:** Include your API key in the `X-API-Key` header: ```bash curl -X GET "https://api.example.com/api/v0/agents" \ -H "X-API-Key: YOUR_COMPANY_API_KEY" \ -H "Content-Type: application/json" ``` Or use the `Authorization` header (OpenAI-compatible): ```bash curl -X GET "https://api.example.com/api/v0/agents" \ -H "Authorization: Bearer YOUR_COMPANY_API_KEY" \ -H "Content-Type: application/json" ``` --- ### Option 2: Personal Access Key Personal access keys are tied to your user account and can access any company you belong to. Use this when you need to access multiple companies or build integrations that work across companies. **Getting a Personal Access Key:** 1. Log in to your dashboard 2. Click on your avatar/profile icon and go to **Profile** 3. Find the **Personal Access Keys** section 4. Click **Create New Key** 5. Give it a name and optionally set an expiration date 6. Copy and securely store your key (it won't be shown again) **Usage:** Personal access keys start with `pak_` and **require** you to specify which company to access using the `X-Company-ID` header: ```bash curl -X GET "https://api.example.com/api/v0/agents" \ -H "Authorization: Bearer pak_your_personal_access_key" \ -H "X-Company-ID: your_company_id" \ -H "Content-Type: application/json" ``` Or using the `X-API-Key` header: ```bash curl -X GET "https://api.example.com/api/v0/agents" \ -H "X-API-Key: pak_your_personal_access_key" \ -H "X-Company-ID: your_company_id" \ -H "Content-Type: application/json" ``` You can also pass the company ID as a query parameter: ```bash curl -X GET "https://api.example.com/api/v0/agents?companyId=your_company_id" \ -H "Authorization: Bearer pak_your_personal_access_key" \ -H "Content-Type: application/json" ``` **Finding Your Company ID:** Your company ID can be found in the dashboard URL when viewing a company, or via the Settings page. --- ### Which Key Type Should I Use? | Use Case | Recommended Key Type | |----------|---------------------| | Single company integration | Company API Key | | Multi-company dashboard | Personal Access Key | | CI/CD pipelines | Company API Key | | Personal automation scripts | Personal Access Key | | Third-party app integration | Company API Key | --- ## Response Format All responses are returned in JSON format. Successful responses include the requested data: ```json { "id": "abc123", "name": "My Agent", "created": "2024-01-15T10:30:00Z" } ``` Error responses follow a consistent structure: ```json { "error": "Description of what went wrong" } ``` ## HTTP Status Codes | Code | Description | |------|-------------| | 200 | Success | | 201 | Created | | 400 | Bad Request - Invalid parameters | | 401 | Unauthorized - Invalid or missing API key | | 403 | Forbidden - Insufficient permissions | | 404 | Not Found - Resource doesn't exist | | 429 | Too Many Requests - Rate limit exceeded | | 500 | Internal Server Error | ## Pagination List endpoints support pagination using `page` and `pageSize` parameters: ``` GET /api/v0/agents?page=1&pageSize=20 ``` Paginated responses include: - `items`: Array of results - `total`: Total number of items - `pages`: Total number of pages - `hasNext`: Whether more pages exist ## OpenAI Compatibility The Chat API (`/api/v0/chat/completions`) is fully compatible with the OpenAI API specification. --- ## Anthropic Compatibility & Claude Code The platform also exposes an **Anthropic Messages API-compatible** endpoint, so any Anthropic SDK — including **Claude Code** — can use the platform as its LLM provider. Requests are billed against your platform credits like any other API usage. ### Endpoints | Endpoint | Description | |----------|-------------| | `POST /api/v0/claude/v1/messages` | Create a message (streaming and non-streaming, tool use supported) | | `POST /api/v0/claude/v1/messages/count_tokens` | Estimate token count for a request | | `GET /api/v0/claude/v1/models` | List available models | Authentication works exactly like the rest of the API: send your API key as `Authorization: Bearer ` or `x-api-key: `. Personal access keys (`pak_...`) also work but require the `X-Company-ID` header, which Claude Code cannot send by default — use a **Company API Key** for Claude Code. ### Setting up Claude Code 1. **Install Claude Code** (skip if already installed): ```bash # macOS / Linux / WSL — native installer curl -fsSL https://claude.ai/install.sh | bash # Or via npm (requires Node.js 18+) npm install -g @anthropic-ai/claude-code ``` On Windows (PowerShell): ```powershell irm https://claude.ai/install.ps1 | iex ``` Verify the install with `claude --version`. See the official docs at https://code.claude.com/docs for more install options. 2. **Get a Company API Key**: Dashboard → **Integrations** → **API Keys** → **Generate New Key**. 3. **Configure Claude Code.** Either export environment variables in your shell: ```bash export ANTHROPIC_BASE_URL="https://api.example.com/api/v0/claude" export ANTHROPIC_AUTH_TOKEN="YOUR_COMPANY_API_KEY" claude ``` Or persist the settings in `~/.claude/settings.json` (applies to all projects) or `.claude/settings.local.json` in a project. Set the model variables to any platform model names — for example: ```json { "env": { "ANTHROPIC_BASE_URL": "https://api.example.com/api/v0/claude", "ANTHROPIC_AUTH_TOKEN": "YOUR_COMPANY_API_KEY", "ANTHROPIC_MODEL": "qwen3.8-max", "ANTHROPIC_DEFAULT_OPUS_MODEL": "kimi-k3", "ANTHROPIC_DEFAULT_SONNET_MODEL": "qwen3.8-max", "ANTHROPIC_DEFAULT_HAIKU_MODEL": "deepseek-v4-flash-0731" } } ``` 4. **Verify** with `/status` inside Claude Code — it should show your custom base URL — or test the endpoint directly: ```bash curl -X POST "https://api.example.com/api/v0/claude/v1/messages" \ -H "Authorization: Bearer YOUR_COMPANY_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "Content-Type: application/json" \ -d '{"model": "qwen3.8-max", "max_tokens": 64, "messages": [{"role": "user", "content": "Hello"}]}' ``` ### Model names The `model` field accepts any model name from `GET /api/v0/models` — any provider, not just Anthropic — so you can run Claude Code on any model the platform offers. When Claude Code sends its default Anthropic model ids (e.g. `claude-sonnet-4-5-20250929`), they are routed by tier to platform models: opus-class requests run on the platform's highest-capability model, sonnet-class on the balanced default, and haiku-class (background tasks) on the fastest low-cost model. Set `ANTHROPIC_MODEL` and the `ANTHROPIC_DEFAULT_*_MODEL` variables to exact platform model names for full control over routing. Optionally set `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1` so Claude Code lists the platform's models in its `/model` picker. ### Notes and limitations - **Streaming** is fully supported (Anthropic SSE event format with keep-alive pings). - **Tool use** is supported: Claude Code's client-side tools (file edits, bash, etc.) are forwarded to the model and executed locally by Claude Code — never on the platform's servers. - Server-side Anthropic tools (web search, code execution), extended thinking blocks, and prompt caching directives are accepted but ignored. - Usage is billed per request based on real token counts and appears in your usage dashboard under the chat feature. ### Using the Anthropic SDK directly ```python import anthropic client = anthropic.Anthropic( base_url="https://api.example.com/api/v0/claude", auth_token="YOUR_COMPANY_API_KEY", ) response = client.messages.create( model="kimi-k3", max_tokens=1024, messages=[{"role": "user", "content": "Hello"}], ) print(response.content[0].text) ``` --- ## MCP (Model Context Protocol) Integration The platform provides an MCP server that allows AI assistants like Claude Desktop, Cursor, Windsurf, and other MCP-compatible tools to interact with the full platform API. ### What is MCP? Model Context Protocol (MCP) is an open standard that allows AI assistants to securely connect to external tools and data sources. With MCP, your AI assistant can: - Browse and manage your AI agents - Create and monitor outreach sequences - Search your knowledge base documents - Generate AI content, images, audio, and video - Execute browser automation tasks - And access every other platform feature ### MCP Server URL ``` https://api.example.com/api/v0/mcp ``` This endpoint implements the **MCP Streamable HTTP Transport** (JSON-RPC 2.0) and is compatible with `mcp-remote` and other MCP clients. ### Available Tools The MCP server provides 3 tools that give access to the entire platform API: | Tool | Description | |------|-------------| | `platform_list_capabilities` | Browse available API endpoints by category (Agents, Sequences, Lists, Documents, etc.) | | `platform_get_action_details` | Get the full specification for an endpoint including required parameters | | `platform_execute_action` | Execute any API endpoint with automatic authentication | ### Connecting Claude Desktop 1. Open your Claude Desktop configuration file: - **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json` - **Windows**: `%APPDATA%\Claude\claude_desktop_config.json` 2. Add the MCP server configuration: ```json { "mcpServers": { "platform": { "command": "npx", "args": ["-y", "mcp-remote", "https://api.example.com/api/v0/mcp"], "env": { "API_KEY": "your_api_key_here" } } } } ``` 3. Restart Claude Desktop 4. You can now ask Claude to interact with your platform data, for example: - "List my AI agents" - "Show me my active sequences" - "Create a new email sequence for cold outreach" - "Search my documents for pricing information" ### Connecting Cursor / Windsurf 1. Open Settings and navigate to the MCP section 2. Add a new MCP server with: - **URL**: `https://api.example.com/api/v0/mcp` - **Authentication**: Bearer token with your API key 3. The platform tools will now be available in your AI assistant ### Connecting via mcp-remote (Generic) For any MCP-compatible client, you can use the `mcp-remote` package: ```bash npx mcp-remote https://api.example.com/api/v0/mcp --header "Authorization: Bearer YOUR_API_KEY" ``` ### Authentication for MCP MCP requests use the same authentication as the REST API: **Using Company API Key:** ``` Authorization: Bearer YOUR_COMPANY_API_KEY ``` **Using Personal Access Key:** ``` Authorization: Bearer pak_your_personal_access_key X-Company-ID: your_company_id ``` ### Example MCP Interactions **List available capabilities:** ```json { "name": "platform_list_capabilities", "arguments": { "category": "Sequences" } } ``` **Get action details:** ```json { "name": "platform_get_action_details", "arguments": { "operationId": "post_sequences.create_sequence" } } ``` **Execute an action:** ```json { "name": "platform_execute_action", "arguments": { "operationId": "get_agents.list_agents" } } ``` ### MCP Endpoints | Endpoint | Method | Description | |----------|--------|-------------| | `/api/v0/mcp/info` | GET | Get MCP server information and capabilities | | `/api/v0/mcp/tools/list` | GET | List all available MCP tools | | `/api/v0/mcp/tools/call` | POST | Execute an MCP tool call | servers: - url: https://api.parallellabs.app security: - CompanyApiKey: [] - BearerAuth: [] CompanyId: [] tags: - name: Agents description: >- Create, manage, and interact with AI agents that handle customer interactions across multiple channels including website chat, email, SMS, and voice. - name: Audio description: Generate text-to-speech audio using ElevenLabs. - name: Browser description: Execute browser automation tasks with natural language. - name: Canvas description: > Create canvas art as shareable images or looping videos — social posts, story graphics, quote cards, announcements, link-preview art. Workflow: author a complete standalone HTML canvas (large text over a photo, color, or gradient, optionally with Lucide icons), then canvas_createCanvas renders it at exact pixel size and returns a permanent public URL. Pass animated=true to record the canvas as a looping MP4 instead of a still PNG — animate it with infinite CSS keyframes per the animation guidelines below, and the response returns videoId and an MP4 url. A still render costs 1 data credit and an animated recording 3; both are only charged on success. Author the HTML to these design guidelines: ## What You Are Making A canvas is a piece of visual art, not a document. Museum-quality, magazine-quality — never cartoony, never clip-art, never a slide. Before writing any HTML, decide a design direction in one sentence (e.g. "Swiss formalism: one monumental word, hard grid, red/black/paper" or "quiet editorial: thin serif, vast negative space, one photograph"). Every choice then serves that direction. ## Brand Style (check first) - Before choosing a direction, check whether the company has brand images saved in the content engine (GET /content/brand-images — content_listBrandImages on the platform API/MCP). Do this BEFORE the first render, not after. - If a brand image exists, its `imageStylePrompt` is the company's established visual style (palette, mood, typography feel, photographic treatment) and its `images` list holds brand assets (logos, product shots, approved photography) with public URLs. Treat these as the source of truth: derive the palette and type choices from the style prompt, and embed brand assets by their exact URL instead of stock or AI-generated stand-ins when a suitable one exists. Never alter, recolor, or distort a logo. - If no brand images exist, or the session already supplies brand context in its instructions, skip the lookup and design from the brief. ## Canvas Setup (exact rules) - Output one complete standalone HTML document. No external CSS/JS files; inline a `