Documentation

Connect any AI to Bazooka

Bazooka runs AI-driven acquisition on LinkedIn and seven other social platforms: lead collection, outbound campaigns, AI appointment setters, content and the pipeline they produce. Everything the dashboard does is available to your own AI or platform through one connector. Bring whichever model you run: Claude, ChatGPT, Mistral, Gemini or open weights.

Start in 5 minutes Browse 273 tools

Overview

The Bazooka AI Connector is a server that speaks the Model Context Protocol (MCP), the open standard AI assistants and agent platforms use to call external tools. Your AI connects to one address, receives a list of tools with typed inputs, and calls them. Each tool is an action in a Bazooka workspace: collect leads, build and launch a campaign, read the inbox, pull the numbers.

MCP is model neutral. Bazooka never needs to know which model is on the other end, and nothing in the connector depends on one vendor. Your model decides which tool to call, Bazooka executes it and returns the result as text.

Connector address: https://app.mybazooka.com/mcp
Transport: Streamable HTTP. One HTTPS POST per request, JSON in, JSON out.
Authentication: Sign-in with OAuth 2.1, or an access key sent as a Bearer token.
Tools: 273 for a workspace, 19 more for partners who manage client workspaces.
Manual for AI agents: https://app.mybazooka.com/mcp/llms.txt

Quickstart

There are two ways in. Both reach the same tools with the same permissions.

A. An assistant with a chat window

In your assistant, add a custom connector (a remote MCP server) with the address https://app.mybazooka.com/mcp.
A Bazooka sign-in page opens. Sign in and approve access.
Start a new chat and paste the one line below.

The one line

Use Bazooka: call get_playbook with topic start_here and follow it step by step, starting with my onboarding.

B. A backend platform or your own agent

In Bazooka, open Settings, AI Connector, Developers, Access keys and create a key. It is shown once.
Give your platform the connector address and the key.
List the tools to check the connection:

curl

curl -s https://app.mybazooka.com/mcp \
  -H "Authorization: Bearer $BAZOOKA_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Authentication

Every request carries Authorization: Bearer .... The token decides which workspace is reached. A workspace is never taken from a tool argument, so a token can only ever act where it was granted.

Sign-in (OAuth 2.1)

For assistants a person uses. The client discovers everything from the address, registers itself and sends the user to a Bazooka sign-in page. No key is pasted and no secret is stored by the user.

Discovery: /.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server on app.mybazooka.com. An unauthenticated request answers 401 with a pointer to them.
Client registration: Dynamic client registration (RFC 7591) and Client ID Metadata Documents.
Flow: Authorization code with PKCE S256. PKCE is required.
Tokens: Access tokens last 1 hour. Refresh tokens last 60 days and rotate on every use.
Scopes: bazooka:read, bazooka:write, offline_access. bazooka:partner is added for partner accounts only.

Access keys

For anything that connects from a server and has no browser: workflow platforms, scheduled agents, your own code. A key is created by a signed-in user in Settings, AI Connector, Developers. It carries that user's access to that workspace.

Format: Starts with bzk_mcp_key_. Sent as Authorization: Bearer <key>.
Access: Read only, or read and write. A read-only key is refused on every tool that changes something.
Expiry: 30 days, 90 days, 1 year, or none.
Storage: Shown once at creation. Bazooka stores only a hash.
Revoking: Settings, AI Connector, Connected apps, Disconnect. The next request is refused.

Treat a key like a password: keep it in your platform's secret store, one key per system, and prefer read only where that is enough.

Connect your AI

The address is the same everywhere: https://app.mybazooka.com/mcp

Claude

Open Settings, then Connectors.
Click Add custom connector and paste the address.
Sign in on the Bazooka page and approve access.

On Team and Enterprise plans an owner adds the connector once in Organization settings, and members click Connect.

Claude Code

Terminal

claude mcp add --transport http bazooka https://app.mybazooka.com/mcp

ChatGPT

In Settings, open Connectors (developer mode), create a connector with the address and complete the Bazooka sign-in.

Grok

In Settings, Connectors, choose the custom MCP option and enter the address.

Cursor, Windsurf, Cline, Zed, Goose, VS Code

mcp.json

{
  "mcpServers": {
    "bazooka": {
      "type": "http",
      "url": "https://app.mybazooka.com/mcp"
    }
  }
}

A client that only speaks stdio can bridge with npx -y mcp-remote https://app.mybazooka.com/mcp.

Mistral and open models

Teams that run on Mistral, or on open weights in their own cloud, connect in the same way. The model stays where you host it. Only the tool calls your model chooses to make, and their results, travel between your stack and Bazooka.

Le Chat

Open Connectors and click Add Connector.
Switch to Custom MCP Connector.
Enter a name (for example bazooka) and the server URL https://app.mybazooka.com/mcp, then click Connect.
Le Chat detects the sign-in. Approve access on the Bazooka page.

Custom connectors are added by a Le Chat administrator. On personal plans that is the account owner.

Your own agent on the Mistral API

Any MCP client library works. List the tools once, hand them to the model as functions, and route each function call back to Bazooka. The example uses the official MCP Python SDK and the Mistral SDK with an access key.

Python

import asyncio, json, os
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
from mistralai import Mistral

BAZOOKA = "https://app.mybazooka.com/mcp"
HEADERS = {"Authorization": f"Bearer {os.environ['BAZOOKA_KEY']}"}
# Give the model the tools this job needs, not all of them.
WANTED = {"get_playbook", "get_workspace_overview", "list_campaigns",
          "get_campaign_analytics", "list_conversations", "get_conversation"}

async def main():
    mistral = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    async with streamablehttp_client(BAZOOKA, headers=HEADERS) as (read, write, _):
        async with ClientSession(read, write) as bazooka:
            await bazooka.initialize()
            listed = (await bazooka.list_tools()).tools
            tools = [{"type": "function", "function": {
                        "name": t.name, "description": t.description,
                        "parameters": t.inputSchema}}
                     for t in listed if t.name in WANTED]

            messages = [{"role": "user",
                         "content": "Which campaign has the best reply rate this month?"}]
            while True:
                reply = mistral.chat.complete(model="mistral-large-latest",
                                              messages=messages, tools=tools)
                msg = reply.choices[0].message
                messages.append(msg)
                if not msg.tool_calls:
                    print(msg.content)
                    return
                for call in msg.tool_calls:
                    result = await bazooka.call_tool(
                        call.function.name, json.loads(call.function.arguments))
                    text = "\n".join(c.text for c in result.content if c.type == "text")
                    messages.append({"role": "tool", "name": call.function.name,
                                     "tool_call_id": call.id, "content": text})

asyncio.run(main())

The same loop works with any model that supports function calling, including self-hosted ones behind an OpenAI-compatible endpoint: tool names, descriptions and JSON Schema inputs map one to one.

Backend platforms

Workflow engines and agent platforms that offer an MCP server connection need two values: the server address and a key.

Create an access key in Bazooka (Settings, AI Connector, Developers).
In your platform, add an MCP server connection with the address https://app.mybazooka.com/mcp and the key as the token.
Save and test. The platform reads the tool list, and each Bazooka tool becomes a step in a workflow or a tool for an agent.

What makes this work well in practice:

Read and write are marked on every tool. Each tool carries the standard MCP annotations readOnlyHint and destructiveHint, so a platform with a read-only connection mode can refuse writing tools before a request leaves.
Two locks are better than one. Pair a read-only connection in your platform with a read-only key from Bazooka where the job only reads.
One key per environment. Name keys after where they live (development, acceptance, production) so each can be revoked without touching the others.
Deterministic steps need no model. A workflow can call a tool such as create_leads or get_campaign_analytics directly with fixed JSON arguments. Use an agent where judgement is needed, and a plain step where it is not.

Protocol reference

Endpoint: POST https://app.mybazooka.com/mcp. No trailing slash.
Protocol versions: 2025-11-25, 2025-06-18 and 2025-03-26. The server negotiates down to what the client asks for.
Format: JSON-RPC 2.0. Responses are plain JSON, not a stream.
State: Stateless. Every request stands alone, so a client may call tools/list or tools/call without a session.
Methods: initialize, tools/list, tools/call, prompts/list, prompts/get, resources/list, ping.

Call a tool

Request

curl -s https://app.mybazooka.com/mcp \
  -H "Authorization: Bearer $BAZOOKA_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": { "name": "list_lead_lists", "arguments": {} }
  }'

Response

{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "content": [
      { "type": "text", "text": "Current Bazooka MCP version 2.26.39 (You're up to date. ...)" },
      { "type": "text", "text": "{ \"count\": 2, \"total\": 2, \"next_cursor\": null, \"lists\": [ ... ] }" }
    ]
  }
}

The answer is the last text block. The first block is a one-line version notice meant for the model. Code that parses results should read the last block, which is JSON for data tools.
Tool failures are results, not protocol errors. A refused or failed call returns "isError": true with a sentence that says what to change. Protocol errors (unknown method, malformed request) use the JSON-RPC error object.
Lists are paged. List tools return next_cursor. Pass it back as cursor for the next page.
Long work is asynchronous. Collecting leads, enrichment, test runs and AI drafts take minutes. The starting tool returns an id at once, and a matching read tool reports progress (for example start_lead_collection then get_lead_collection).
401 means the token. Missing, unknown, expired or revoked. Nothing else answers 401.

How an agent runs Bazooka

Tools say what can be done. Playbooks say how to do it well. They are served by the connector itself, so an agent on any model follows the same method.

get_playbook with topic start_here: what Bazooka is, the order of work, and which playbook fits each job.
get_onboarding: the setup checklist. Until it is complete, onboarding comes first.
read_operator_file with file operator_memory: what earlier sessions learned about this workspace. Write back with write_operator_file, so an agent without memory of its own still continues where the last one stopped.
Then the work itself: collect leads, enrich, build the campaign, run it in Test Mode, launch, read the numbers, improve.

The full manual, written for an AI to read, is at https://app.mybazooka.com/mcp/llms.txt. It is public and needs no sign-in. For an agent with a system prompt you control, this is enough:

System prompt

Bazooka runs our outbound and inbound acquisition. Its MCP server is at
https://app.mybazooka.com/mcp and its operating manual is at
https://app.mybazooka.com/mcp/llms.txt.

Start with get_playbook topic start_here and follow it step by step.
Call get_playbook for the matching topic before any other job, and keep
notes in the operator files (read_operator_file, write_operator_file).

Never send a message, launch a campaign or publish a post without
showing the exact content and getting explicit approval first.

Choosing a tool set

The connector exposes 273 tools. Large assistants load them on demand. An agent you build yourself should be given only the tools its job needs: smaller models choose more accurately from a short list, and every tool definition costs tokens on every call. Most agent platforms let you pick tools per agent. Good starting sets:

Reporting: get_workspace_overview, get_system_status, get_analytics, list_campaigns, get_campaign_analytics, get_step_analytics, list_appointments
Inbox: list_conversations, get_conversation, send_message, set_conversation_ai, get_lead, update_lead
Lead intake from your own systems: create_leads, create_lead_list, add_leads_to_list, add_leads_to_campaign, apply_labels_to_leads, search_leads
Campaign building: get_playbook, create_campaign, set_first_message, create_campaign_step, assign_account_to_campaign, check_campaign_readiness, start_campaign_test, get_campaign_test, launch_campaign
Lead collection: get_playbook, list_lead_collection_sources, start_lead_collection, get_lead_collection, import_sales_navigator_search, add_lead_collection_to_campaign

Always include get_playbook for an agent that does more than read: it is how the agent learns the method for the job in front of it.

Agencies and partners

A partner account administers many client workspaces. Its connection, by sign-in or by access key, reaches all of them, and one connection is enough to serve every client.

Every workspace tool gains a required client argument: the client's name or id, as list_clients shows it. A call without it is refused, never guessed.
Every answer names the client it acted on.
Partner tools cover the book of business: create a client workspace, invite its admins, set their access, branding and pricing.
A partner connection can only reach that partner's own clients. A client's own connection never sees partner tools.

tools/call on a partner connection

{
  "jsonrpc": "2.0", "id": 7, "method": "tools/call",
  "params": {
    "name": "get_campaign_analytics",
    "arguments": { "client": "Northwind", "campaign_id": "..." }
  }
}

Permissions and safety

Read and write are separate. bazooka:read covers reading the workspace. bazooka:write is needed for every tool that changes something. There is no catch-all tool.
Actions that reach a real person are marked. Sending a message, launching a campaign and publishing a post carry destructiveHint, so assistants ask for confirmation first. An agent that runs unattended should be built to do the same.
A connection has the access of the person who created it. It sees what that person sees in the dashboard and nothing more.
Logins never go through a chat. Connecting a LinkedIn or other platform account, a calendar or a payment happens on a hosted page. The tool returns the link.
Every call is logged. Tool, arguments, result status and duration are recorded per connection.
Tokens and keys are stored as hashes. Disconnecting under Settings, AI Connector, Connected apps takes effect on the next request.

Tool reference

273 workspace tools and 19 partner tools. The exact inputs of each tool, as JSON Schema, come from tools/list on your own connection, which is always current.

Onboarding and AI operator files

The setup checklist your AI works through first, and the notes it keeps for next time.

get_onboardingRead

The onboarding checklist with each item done or open, what it needs, and the next step. Most items tick themselves from your real settings.

update_onboarding_itemWrite, confirm first

Marks a checklist item done or open, with a note. Used for the items that need your decision, like which platforms to start on. Saving the website also replaces the Company domain.

complete_onboardingWrite

Checks the onboarding off for good once every required item is done, or lists what is still open. Your settings stay editable.

read_operator_fileRead

Reads the AI Lead Collection Skill file or the Operator Memory file, the notes your AI keeps in AI Super Agents.

write_operator_fileWrite

Adds to or rewrites one of the two operator files. Every save keeps a version.

list_operator_file_versionsRead

The saved history of an operator file, newest first.

Workspace and health

Orientation and the answer to "is anything broken".

get_workspace_overviewRead

Plan, connected accounts, campaign counts and today's sending activity in one snapshot.

get_system_statusRead

Disconnected accounts, accounts out of InMail credits, threads waiting on a human.

get_recent_activityRead

A chronological feed of messages sent, replies received and meetings booked.

get_workspace_settingsRead

Company context, ICP, booking link, AI instructions and template variables.

update_workspace_settingsWrite, confirm first

Updates your ICP, booking link, timezone, content instructions and competitor positioning.

Sending accounts

The accounts that do the sending, on every platform, plus WhatsApp and what you bought.

list_linkedin_accountsRead

Each account with health, today's usage against its limits and Sales Navigator state.

get_account_healthRead

connect_linkedin_accountRead

Gives you a link that opens Add LinkedIn account in Bazooka, where you sign in yourself.

update_account_limitsWrite, confirm first

Sets one account's daily ranges on any of the eight platforms, with the same ceilings as its card on the Accounts page. Saving custom values switches Recommended limits off.

set_account_warmupWrite, confirm first

Switches an account's warm-up on or off like the flame on its card: Mode 1 ramps for 7 days, Mode 2 for 14 days with a quiet start.

set_account_activeWrite, confirm first

The on/off switch of a LinkedIn, X or WhatsApp account card. An account that is off sends nothing.

get_account_reconnect_linkRead

Every signed-out account with the link to its Accounts section, why it is out and what to click there.

upgrade_account_to_sales_navigatorWrite, confirm first

The card's free upgrade from Classic to Sales Navigator, so the account can also send InMails.

remove_accountWrite, confirm first

Removes an account exactly as the Accounts page does. On LinkedIn this is permanent and deletes its browser; it tells you everything it would destroy before you confirm.

create_whatsapp_connect_linkWrite

A one-hour link to a QR code page that connects the workspace's outbound WhatsApp account.

list_notification_recipientsRead

The phone numbers that receive the workspace's WhatsApp alerts, up to 10.

save_notification_recipientWrite, confirm first

Adds a number to the WhatsApp alert recipients, or replaces one.

remove_notification_recipientWrite, confirm first

Takes a number off the WhatsApp alert recipients.

list_marketplace_ordersRead

Every Marketplace order: active, being set up (with its step) and past, plus your free and used senders.

Profile setup

Read, write and generate the profiles your accounts show to prospects.

get_linkedin_profileRead

Reads one LinkedIn account's live profile, the saved draft and the queued changes.

update_linkedin_profileWrite

Changes a LinkedIn account's real profile: headline, About, roles, skills, photo and banner.

generate_linkedin_profileWrite

Writes a complete LinkedIn profile for one account with Bazooka's profile AI.

get_social_profileRead

Reads one Instagram, Facebook, X, TikTok, Reddit, Threads or Discord profile.

update_social_profileWrite, confirm first

Changes one of those profiles field by field.

ai_configure_social_profilesWrite, confirm first

Has the profile AI write the photo, banner and bio of one or more profiles from your company context.

copy_linkedin_profile_to_socialsWrite, confirm first

Gives an account's other profiles the same face as its LinkedIn profile.

get_social_profile_jobRead

Shows one queued profile change and how far it is.

cancel_social_profile_jobWrite

Calls off a queued profile change that has not started.

Links and accounts

A clickable link to any page, and accounts on every platform connected with safe limits.

list_app_linksRead

Every page in Bazooka, what it shows and the link for it.

get_app_linkRead

A link that opens that exact page: a campaign, a lead list, a lead, an accounts section and more. Signed out, it opens right after you sign in.

get_connect_account_linkRead

A link that opens Add account for that platform, what you will be asked for, and the accounts you already have there.

apply_recommended_limitsWrite, confirm first

Turns recommended limits on with the same daily ranges the Accounts page uses, replacing the current limits, for the accounts you pick, every account on one platform, or all of them. It can also switch them off and keep the current values.

Lead collection and enrichment

Finding your dream clients on eight platforms, filtering them with AI, and putting them into a campaign.

list_lead_collection_sourcesRead

Every source on LinkedIn, Instagram, Facebook, X, TikTok, Reddit, Threads and Discord, the link each one takes, who it collects and which of your accounts can run it.

start_lead_collectionWrite, confirm first

Queues a collection from a post, profile, group, community, subreddit or server, or of your own followers, on one of your accounts. People land in a lead list as they are found. A subreddit stops at 500 people and your own followers at 1,000 unless you set a number.

get_lead_collectionRead

Status, people collected, how many are new, the target list and a sample of who was found.

list_lead_collectionsRead

Recent collections, newest first, by platform or status.

list_saved_linksRead

Your Saved links: every post, profile, group, community, subreddit, server and Sales Navigator search found so far, per platform, with its size, notes and whether it was collected yet.

save_linksWrite

Saves up to 100 lead sources at once to Lead Collection > Saved links, with why each fits and its size, so research keeps building up. A link already saved gets the new details.

delete_saved_linksWrite, confirm first

Deletes links from your Saved links. Leads already collected from them stay.

cancel_lead_collectionWrite

Stops a queued or running collection. Everyone already collected stays in the list.

start_ai_lead_enrichmentWrite

AI workers read every lead in your lists and mark each one in or out against your brief, 100 leads per worker, all at once.

get_ai_lead_enrichmentRead

Progress, leads kept and filtered out, a sample of the kept ones, and page by page every kept or filtered-out lead with the AI's reason.

list_ai_lead_enrichmentsRead

Recent enrichment runs with their brief, the lists they ran on, their status and how many leads each kept or filtered out.

preview_ai_lead_enrichmentRead

What a new enrichment of those lists would run on, without starting one: how many leads are still visible after earlier enrichments, and a sample of them.

revert_ai_lead_enrichmentWrite, confirm first

Brings back every lead an enrichment filtered out, like the Revert enrichment button. The lead lists themselves are not changed.

restore_ai_lead_enrichmentWrite, confirm first

Makes a reverted enrichment count again, like Restore under Recent enrichments, so the leads it filtered out are hidden again.

save_enriched_leads_to_listWrite

Copies the leads an enrichment kept into a new or existing lead list, in the background.

get_list_save_jobRead

Whether a save into a lead list has finished, how many leads it added and which list they went into.

add_lead_list_to_campaignWrite, confirm first

Adds every lead in a list to a campaign on the list's platform. Leads already in it are skipped.

add_lead_collection_to_campaignWrite, confirm first

Adds the leads of a collection to a campaign or lead list, also while it is still running: what is collected so far, plus every lead that follows.

Finding prospects

Sales Navigator searches driven from the chat.

build_sales_navigator_search_urlRead

Turns titles, seniority, companies, industries, locations, headcount and spotlights into the Sales Navigator search URL, so you can check the count before importing.

import_sales_navigator_searchWrite, confirm first

The Import Leads of AI Lead Collection: a Sales Navigator account pages through the search in its own browser and streams up to 2,500 people into a lead list, and optionally a campaign.

search_linkedin_prospectsWrite

Runs a real Sales Navigator search on one of your accounts and collects the matches. Takes minutes.

get_prospect_searchRead

Progress, how many people were found, and a preview of who they are.

save_prospect_searchWrite

Files the collected people into a lead list, a campaign, or both.

cancel_prospect_searchWrite, confirm first

Halts collection. Optionally discards what was collected.

list_prospect_searchesRead

Recent searches with status and result counts.

Sales Navigator at scale

Count a search before collecting it, collect searches of any size, and keep licenses in sync.

how_many_leads_in_sales_navigator_searchWrite

Counts the leads in a Sales Navigator people search before you collect them.

start_sales_navigator_harvestWrite, confirm first

Collects every person in a Sales Navigator search of any size by splitting it into slices under the 2,500 limit of one search.

get_sales_navigator_harvestWrite

Where a harvest stands: slices done, leads collected, what is next.

list_sales_navigator_harvestsRead

Every harvest of the workspace, newest first.

update_sales_navigator_harvestWrite, confirm first

Pauses, resumes, renames or stops a harvest.

edit_sales_navigator_harvest_slicesWrite, confirm first

Steers the slices of a harvest by hand. The autopilot normally does this.

find_sales_navigator_locationRead

Looks up the location ids Sales Navigator uses, by name or by the place they sit in.

sync_sales_navigator_contractsWrite

Syncs the Sales Navigator licenses and InMail credits of one account or all of them.

Leads and lists

Everyone in the database, and how they are organised.

search_leadsRead

The Leads Database's filters: platform, lists, campaigns, status, labels, open profile, activity, processed, replies and bookings, with the total and page by page.

get_leadRead

The full record: profile and company data, every platform the lead is on, custom fields, campaigns and recent messages.

create_leadsWrite

Creates leads, optionally attached to a campaign. Skips duplicates.

update_leadWrite

Updates status, labels, notes, email and phone.

enrich_leadsWrite

Runs an option of the Enrich menu in the background: AI website analysis, LinkedIn activity, open profile, or which of your accounts they are connected to.

get_lead_bulk_jobRead

The progress of a background lead job: done, failed and the first errors.

cancel_lead_bulk_jobWrite, confirm first

Does what the progress bar's Cancel does. The job usually still finishes, and the answer says so.

import_leadsWrite

The Upload CSV: maps the columns, skips duplicates, adds a label or a LinkedIn list, and turns extra columns into variables.

export_leadsRead

The Leads Database's CSV export, with the same columns, as text.

delete_leadsWrite, confirm first

Permanently deletes leads with their conversations and campaign places, in the background.

list_labelsRead

Every label defined in the workspace.

apply_labels_to_leadsWrite

Adds labels in bulk, creating any that do not exist yet.

list_lead_listsRead

Your lists with their platform and size, searchable and sorted like the lead lists page.

create_lead_listWrite

Creates an empty lead list for one platform.

list_lead_list_itemsRead

The leads in one list, with where each was collected.

add_leads_to_listWrite

Adds chosen leads, or every lead matching a search, to a list of their platform.

remove_leads_from_listWrite, confirm first

Removes leads from one list. The leads themselves stay.

rename_lead_listWrite

Gives a list a new name.

delete_lead_listWrite, confirm first

Deletes a list and its items for good. The leads stay in the Leads Database.

Campaigns

Build, write, launch and steer the outreach itself.

list_campaignsRead

Every campaign with status, type, limits and lead counts.

get_campaignRead

Settings, assigned accounts, the full message sequence and lead counts by status.

list_campaign_platformsRead

The eight platforms, which are enabled for you, your accounts on each, and how each platform's flow works.

list_sending_accountsRead

Your accounts on every platform, with warm-up state and campaign assignments.

create_campaignWrite

Creates it as a draft on the platforms you pick, with the default flow. Sends nothing.

add_campaign_platformsWrite

Adds more platforms to an existing campaign.

get_campaign_buildRead

Platforms, accounts, first message, flow steps, AI setter and launch readiness, like the builder shows it.

set_first_messageWrite

Sets the First Message: AI openers, fixed templates, or both.

preview_messageRead

Renders a message template for one real lead with every variable filled in, like Preview in the step editor. Nothing is sent.

create_campaign_stepWrite

Adds a follow-up (or connection/friend request) on any of the campaign's platforms, with a humanised delay.

update_campaign_stepWrite

Changes a step's humanised delay window, its position, or the copy of a step with one variant.

get_campaign_stepRead

A step as its editor shows it: the delay, the A/B variants with their files, and the AI agents writing it.

set_campaign_step_variantsWrite, confirm first

Saves a step's A/B variants, each with an optional file, and the AI agents that take a share of it.

set_first_message_attachmentWrite

Adds, replaces or removes a file on one First Message template.

get_campaign_settingsRead

What the Settings dialog shows: working hours, Active Days, AI Warm-Up Mode and its progress, test mode.

set_campaign_active_days_and_warmupWrite

Saves Active Days and the campaign's AI Warm-Up Mode, which ramps its accounts up over 7 or 14 days.

duplicate_campaignWrite

Copies a campaign into a new draft with its flow, variants, AI settings and accounts, without its leads.

create_account_warmup_campaignWrite

Creates an AI Account Warm-Up campaign: human feed sessions that age an account and send nothing.

delete_campaignWrite, confirm first

Deletes a campaign and all its data for good, after you repeat its name. Leads stay.

reset_test_campaignWrite, confirm first

Puts a paused test-mode campaign back to draft with its leads pending, like the Reset button.

delete_campaign_stepWrite, confirm first

Removes a step from the sequence permanently.

add_leads_to_campaignWrite

Adds existing leads to the campaign's pool.

remove_leads_from_campaignWrite, confirm first

Removes leads from the pool. The leads themselves stay.

assign_account_to_campaignWrite

Attaches a sending account on any platform so the campaign can send.

unassign_account_from_campaignWrite, confirm first

Detaches the account from the campaign.

update_campaign_settingsWrite

Changes name, limits, working hours, timezone and test mode.

check_campaign_readinessRead

Runs the same pre-launch checks as the dashboard and lists what is missing.

launch_campaignWrite, confirm first

Starts real sending on every platform of the campaign, after the same checks as the dashboard.

pause_campaignWrite, confirm first

Stops sending now or after today's scheduled sends finish.

resume_campaignWrite, confirm first

Resumes a paused campaign today or tomorrow.

stop_campaignWrite, confirm first

Full stop, returning unworked leads to the pool.

set_campaign_ai_modeWrite, confirm first

Configures the campaign's AI appointment setter: mode, instructions and lead magnet delivery messages.

configure_ai_follow_upWrite, confirm first

Configures the AI follow-up agent that chases non-replies.

Test mode

See exactly what a campaign would say before it goes live.

start_campaign_testWrite, confirm first

Runs the campaign on one real lead the way the Test Mode tab does and writes its first message. No message is sent. With AI openers and a lead not researched yet, your sending LinkedIn account pauses its running session and visits the lead's LinkedIn profile for real (the lead may see the visit), which takes a few minutes.

get_campaign_testWrite

The test's progress and the conversation so far. While an AI-opener test is still preparing, each check moves it forward: once the profile visit is done, the paused session resumes and the AI opener writes the first message.

send_test_replyWrite

Answers the test as the prospect and shows how the AI appointment setter responds. Nothing reaches the lead.

list_campaign_testsRead

Earlier test runs with their status.

get_test_run_logsRead

The test run's AI Logs: every AI call, and on request its prompts, tool calls and response.

Inbox and replies

The conversations your outreach produced.

list_conversationsRead

Conversations on every platform, with the inbox's filters: Needs Attention, AI active, follow-up due, platform, account and search.

get_conversationRead

The full message history with the lead's details.

send_messageWrite, confirm first

Sends a real message from the thread's own account, optionally with a file. The AI goes off in that thread first. Always asks you first.

set_conversation_aiWrite, confirm first

Hands a thread to a human (listed under Needs Attention when there is a reason), or gives it back to the AI setter.

send_sales_assetWrite, confirm first

Sends one of your lead magnets, personalised for that lead, like Attach sales asset in the chat.

share_conversationWrite

Creates a read-only share link to a conversation or a test run, like Share link in the dashboard. Anyone with the link can read it.

resync_conversationWrite

Runs the chat's Sync, or the Sales Navigator sync a manual reply needs.

reset_conversationsWrite, confirm first

Deletes the stored messages and resets the threads' state. Nothing is sent.

delete_conversationsWrite, confirm first

Deletes threads and their stored messages from Bazooka. The platform is untouched.

Analytics and pipeline

What is working, and what is stalling.

get_analyticsRead

The workspace-wide funnel, counting each person once across campaigns.

get_campaign_analyticsRead

One campaign's funnel, its rates with the dashboard's definitions, and the campaign page's tiles per platform.

get_variant_analyticsRead

Every variant of a step (AI openers, templates, AI agents, retired ones) with sent, replies, positive replies and bookings.

list_metric_leadsRead

The people behind any number, like clicking a metric: on the Analytics page, a campaign tile or a variant.

get_campaign_ai_breakdownRead

Per custom instruction, lead magnet and delivery message of a campaign: used, replies, positive replies and bookings.

get_lead_magnet_analyticsRead

One lead magnet across every campaign: sent, replies and bookings after it.

get_step_analyticsRead

Per-step sends, replies and bookings, so you can see which step carries the sequence.

list_appointmentsRead

Meetings on every calendar with the lead and campaign each came from, and whether the chat or a lead magnet booked it.

list_pipeline_stagesRead

Your board's stages in order with lead counts.

move_lead_to_stageWrite

Moves a lead between pipeline stages.

get_lead_magnet_performanceRead

Delivery and booking rates per lead magnet template.

get_ai_agent_analyticsRead

Live performance of every AI appointment setter and AI opener, per agent and per version.

send_ai_reportWrite

Emails a full AI report of the workspace, with a PDF.

get_ai_report_statusRead

Whether a requested AI report is still being written, was sent or failed.

Content posts

What you publish on LinkedIn, before and after it goes out.

list_content_postsRead

Posts with status, approval state and schedule.

get_content_postRead

One post with its text, image, versions, schedule and what can still be done with it.

create_content_postWrite

Creates a post waiting in the Approve tab. Nothing publishes until approved.

create_manual_postWrite, confirm first

The Manual post: your own text, posted now, scheduled or saved, without approval, with an optional keyword lead magnet.

refine_content_postWrite, confirm first

Asks the Post Approver to change a post; each refinement becomes a new live version.

switch_content_post_versionWrite, confirm first

Makes an earlier version of a post live again.

edit_content_postWrite, confirm first

Edits an unpublished post like the post dialog. An approved post only moves.

schedule_content_postWrite

Reschedules an approved post.

approve_content_postWrite, confirm first

Approves (schedules into the next free slot) or rejects a post. Asks you first.

publish_content_post_nowWrite, confirm first

Publishes a ready post as the account's next action, like Post Now.

cancel_content_postWrite, confirm first

Takes an unpublished post off the calendar and keeps it as cancelled.

delete_content_postWrite, confirm first

Deletes the post record.

list_post_engagersRead

The people collected from a post's comments, and whether they got the lead magnet.

Lead magnets, bookings and forms

What you send mid-conversation, and what happens once someone books.

list_lead_magnetsRead

Your lead magnets, which are on, and their files.

get_lead_magnetRead

One lead magnet in full: file, link and personalisation settings.

create_lead_magnetWrite, confirm first

New Lead Magnet from a PDF link, personalised per lead. Active ones are sent by the AI setter.

update_lead_magnetWrite, confirm first

Renames it, replaces the file or converts HTML to PDF, like its Edit dialog.

set_lead_magnet_activeWrite, confirm first

Turns a lead magnet on or off for the AI setter and the chat.

duplicate_lead_magnetWrite

Copies a lead magnet, switched off.

delete_lead_magnetWrite, confirm first

Deletes a lead magnet and its analytics for good.

generate_lead_magnetWrite

Generates the personalised document and returns a link. Takes a few minutes.

get_booking_setupRead

Bookings > Calendars: the saved link, connected calendars, the active one, your booking pages and the link the AI sends.

get_calendar_connect_linkWrite

The link that connects your calendar straight from the chat: Bazooka Booking (your Google or Microsoft calendar), Cal.com, Calendly or iClosed.

set_active_calendarWrite, confirm first

Chooses the one calendar that books meetings and whose link the AI sends.

disconnect_bazooka_calendarWrite, confirm first

Disconnects the calendar behind Bazooka Booking; its booking pages stop taking bookings.

save_booking_pageWrite, confirm first

Creates or edits a Bazooka booking page and returns its public link.

duplicate_booking_pageWrite

Copies a booking page with every setting.

delete_booking_pageWrite, confirm first

Deletes a booking page and its Booked records. Meetings stay on the calendar.

list_bookingsRead

The Booked list of your Bazooka pages, including people who dropped off before picking a time.

list_formsRead

Your Bazooka forms with their links and response counts.

save_formWrite

Creates or edits a form with its questions and texts, and returns its link.

duplicate_formWrite

Copies a form with all its questions, without responses.

delete_formWrite, confirm first

Deletes a form and every response for good.

list_form_responsesRead

The responses with every answer, searchable.

get_appointment_messagesRead

The appointment confirmation message and the reminder steps.

set_appointment_confirmation_messageWrite

Saves the WhatsApp message sent a few minutes after someone books.

save_appointment_reminderWrite

Adds or edits a reminder sent a set time before the booked call.

delete_appointment_reminderWrite, confirm first

Deletes one appointment reminder.

AI openers

The agents that write each prospect's first message.

list_ai_openersRead

Bazooka's openers and your own, with their messaging frameworks.

create_ai_openerWrite

The First Message pop-up's New AI Opener: a name plus a messaging framework, optionally put straight on a campaign.

update_ai_openerWrite, confirm first

Rewrites your opener, or makes a private copy of a Bazooka opener with your change.

delete_ai_openerWrite, confirm first

Retires one of your own openers.

AI sales team and Archie

Who answers, opens, engages and enriches, and building your own agents.

get_ai_sales_teamRead

Bazooka's Super AI agents and your own per job, and how traffic is split between them.

set_bazooka_ai_agentWrite, confirm first

Switches a Bazooka Super AI agent on or off. Off needs your own enabled agent of that type first.

chat_with_archieWrite

Talks to Archie, Bazooka's agent builder, who drafts the agent's full prompt with you.

list_archie_chatsRead

Your chats with Archie, newest first, like the Chats panel in the agent builder.

get_archie_chatRead

The messages of one Archie chat and the latest draft prompt on its draft board.

save_ai_agent_from_archieWrite

Saves the draft as your own agent (switched off until you turn it on).

get_own_ai_agentRead

The full prompt of one of your own agents, the live version or an earlier one, with its version history.

activate_ai_agent_versionWrite, confirm first

Makes one saved version of your own agent the live one.

delete_own_ai_agentWrite, confirm first

Retires one of your own agents with all its versions, so it gets no more traffic. Refused while it is the last one switched on and Bazooka's agent of that type is off.

test_ai_agentRead

Runs your agent on a made-up conversation without sending anything.

set_own_ai_agent_enabledWrite, confirm first

Switches your own agent on or off, which changes the traffic split.

list_ai_trainingRead

Custom instructions for Bazooka's agents, per agent type.

create_ai_trainingWrite, confirm first

Adds an instruction (max 1000 characters) to one of Bazooka's agents.

set_ai_training_enabledWrite, confirm first

Enables or disables one instruction immediately.

update_ai_trainingWrite, confirm first

Edits the title, text (max 1000 characters) or on/off state of an instruction. The agent follows it from its next message.

delete_ai_trainingWrite, confirm first

Deletes an instruction permanently. The agent stops using it immediately.

edit_own_ai_agentWrite, confirm first

Saves a new version of one of your own AI agents with targeted edits to its prompt.

AI Engagers

The agents that like and comment on a prospect's posts during a profile view.

list_engager_agentsRead

Lists the AI Engagers.

get_engager_agentRead

Returns one AI Engager in full, with its versions.

create_engager_agentWrite

Creates one of your own AI Engagers.

update_engager_agentWrite, confirm first

Changes an AI Engager by saving a new version. The previous one stays.

test_engager_agentRead

Runs an AI Engager on a post and returns the comment it would write, or why it would not comment.

get_engagement_settingsRead

Shows, per platform, what happens to a prospect's posts during a profile view.

set_engagement_settingsWrite, confirm first

Switches liking and commenting during profile views on or off for a platform.

Company brain and knowledge base

What every AI agent knows about your business.

get_company_brainRead

Company context, AI identity, competitor positioning, ICP and knowledge base totals.

save_company_contextWrite, confirm first

Writes a company context block every agent reads.

delete_company_contextWrite, confirm first

Deletes a company context block. Your agents stop reading it immediately.

draft_company_contextWrite

Bazooka's context writer reads your site and drafts it. Nothing is saved until you approve.

set_ai_identityWrite, confirm first

Chooses whether agents speak as the founder or as an AI assistant.

set_competitor_positioningWrite, confirm first

What the setter says when prospects compare you with alternatives.

read_website_pageRead

Fetches a public page as text, for example to turn your FAQ into answers.

add_knowledge_base_entryWrite, confirm first

Adds up to 100 Q&A pairs at once, embedded so the AI finds them.

update_knowledge_base_entryWrite, confirm first

Edits the question or the answer of one Q&A pair.

delete_knowledge_base_entryWrite, confirm first

Deletes one Q&A pair from the knowledge base.

search_knowledge_baseRead

Runs the same search the AI setter uses and shows the best answer.

add_knowledge_documentWrite, confirm first

Adds a text document the AI can quote from.

add_knowledge_fileWrite

Adds a PDF, Word, Excel, CSV or text file from a link, read and indexed in the background.

list_knowledge_documentsRead

Your uploaded files and text documents, with their processing status and size.

delete_knowledge_documentWrite, confirm first

Deletes a document and all its sections from the knowledge base.

get_company_context_chatRead

Returns a company context drafting chat and its latest draft.

AI Inbound

Creators you track, and AI Modes that turn their posts into yours.

track_creatorWrite

Pulls their posts into your pool, now and daily.

list_tracked_creatorsRead

The LinkedIn creators you track, whether tracking is on, how many of their posts are in your pool, when they last synced and the AI Modes that use them.

sync_tracked_creatorWrite

Pulls a tracked creator's newest posts into your pool now instead of waiting for the daily sync.

set_tracked_creator_statusWrite

Pauses or resumes the daily post sync for a creator. Posts already in the pool stay.

untrack_creatorWrite, confirm first

Removes a creator and their pooled posts. An AI Mode that only uses this creator stops producing posts.

list_creator_postsRead

The post pool, best-performing first.

list_ai_modesRead

Every AI Mode with its on or off state, sources, pool size, publishing accounts, interval and approval setup.

get_ai_modeRead

One AI Mode in full: sources, post pool, content and image instructions, images, accounts, interval and approval.

save_ai_modeWrite, confirm first

Every New AI Mode setting: sources, pool, content and image instructions, fallback images, accounts, interval, approval.

write_content_instructionsRead

Bazooka's writer drafts the AI content instructions from your brief.

write_image_instructionsRead

Bazooka's writer drafts the AI image instructions from your description of the style. Nothing is saved.

list_image_poolRead

Your image pool: the images AI Modes can post, remix or fall back to.

add_images_to_poolWrite

Copies public image links into your image pool so AI Modes can use them.

generate_post_imageWrite

Generates an image with AI and saves it to your image pool.

browse_image_poolRead

The image pool's folders and the images in one of them.

organize_image_poolWrite, confirm first

Creates, renames or deletes folders and moves images between them.

delete_pool_imagesWrite, confirm first

Removes images from the pool. Posts that use them keep them.

remix_creator_post_nowWrite, confirm first

Runs the AI Mode's remix on one pool post right away.

configure_ai_mode_publishingWrite, confirm first

Sets an AI Mode's X and Facebook mirrors and its keyword lead magnet funnel.

run_ai_mode_nowWrite, confirm first

Creates the next post right away; with approval on it waits for you.

set_ai_mode_enabledWrite, confirm first

Save and activate, or pause.

delete_ai_modeWrite, confirm first

Deletes an AI Mode and its pool selection. Posts it already made stay in the content hub.

save_ai_mode_presetWrite

Stores the setup for your next AI Mode.

list_ai_mode_presetsRead

Your saved AI Mode presets.

get_ai_mode_test_postsRead

Collects the test posts an AI Mode wrote in a test run.

Your team and notifications

Who can open what in the workspace, and the notification bell.

list_teamRead

Your teammates with their role, the sections they can open and their alerts, plus pending invites.

invite_teammateWrite

Emails an invite with the role and sections you choose. Admins only.

set_teammate_accessWrite, confirm first

Changes a teammate's role, sections and sign-out alerts. Admins only.

list_notificationsRead

What the bell shows, with the running collections and lead jobs.

mark_notifications_readWrite

Marks notifications as read.

dismiss_notificationsWrite, confirm first

Dismisses notifications from the bell.

Capacity and funds

Quotes and checkout links for more sending capacity and Sales Navigator licenses.

order_sales_navigator_licenseWrite

Orders Sales Navigator licenses for one LinkedIn account.

get_marketplace_quoteRead

Prices an order for more sending capacity before it is placed.

create_marketplace_checkoutWrite

Creates a secure checkout link for more sending capacity. Payment happens in the browser.

create_add_funds_linkWrite

Creates a secure checkout link that adds funds to the workspace.

Playbooks and the Bazooka skill

How your AI knows the right way to do each job.

get_playbookRead

Bazooka's step-by-step playbook for a job, which the AI loads before it starts. Start here walks the whole path: onboarding, lead collection, campaigns and the improvement loop.

get_bazooka_skillRead

Links the downloadable Claude Skill and a memory text for other AIs.

get_ai_resultRead

Collects the answer of an AI function that was still running when its tool call returned.

run_bazooka_toolWrite, confirm first

Runs any Bazooka tool by name. For clients whose tool list was loaded before a newer tool shipped.

update_bazooka_mcpRead

Brings a conversation onto the newest connector version and returns what changed.

Your book of business

Partner connectionsEvery client at once, and what needs you today.

get_partner_overviewRead

Totals across every client: accounts, campaigns, leads, replies, meetings, plus a list of what needs attention.

list_clientsRead

Every client workspace with its plan, account health and headline numbers. The names here are what you refer to a client by.

get_clientRead

One client in full: plan and billing, its users and their access, accounts, campaigns and funnel.

get_partner_activityRead

Messages, replies and meetings per client over a period, ranked, and it names the clients sending nothing.

Provisioning clients

Partner connectionsOnboarding and offboarding, from the chat.

create_clientWrite, confirm first

Gives you a secure checkout link at the price of your next organization. Once paid, the company is created and its admin gets the AI operator setup in your brand. On custom pricing it is created right away.

delete_clientWrite, confirm first

Permanently deletes a client and cancels its subscription. Requires you to repeat the name back.

create_snapshotWrite

Freezes a set-up client as a template (never its accounts), so the next client starts with its campaigns, agents and knowledge ready.

apply_snapshotWrite

Stamps a snapshot onto a client created in the last 7 days: they only connect accounts and launch.

borrow_demo_accountWrite

Lends a live account to your demo workspace for lead collection and Test Mode. A demo never launches, and the source account is never touched.

Client users and access

Partner connectionsWho can get into which client, and what they see.

invite_client_adminWrite

Emails the AI operator setup in your brand: they set a password, connect their own AI, and it runs their workspace.

list_client_usersRead

The people in a client workspace, their role, sections and alert settings.

set_client_user_accessWrite, confirm first

Sets which sections a client user can see, and whether they get email alerts.

remove_client_userWrite, confirm first

Permanently removes someone's access to a client workspace.

Branding, pricing and your team

Partner connectionsThe white-label account itself.

get_partner_brandingRead

Your display name, logo, brand colour and custom domain.

update_partner_brandingWrite, confirm first

Updates the branding every one of your clients sees, immediately.

get_partner_pricingRead

Per-client subscriptions by tier with renewal dates, any custom pricing, and the monthly total.

list_partner_teamRead

Your partner admins plus any pending invitations.

invite_partner_adminWrite, confirm first

Invites someone to co-administer the partner account, with access to every client.

revoke_partner_inviteWrite, confirm first

Revokes a pending partner admin invitation.

Troubleshooting

The client cannot reach the server. The address is exactly https://app.mybazooka.com/mcp, over HTTPS, with no trailing slash.
Sign-in says the account is not attached to a workspace. The user needs to belong to a Bazooka workspace. An admin invites them from Settings, Team.
A tool says the write permission was not granted. The connection is read only. Reconnect and approve both permissions, or create a read and write key.
Requests started answering 401. The key expired or the connection was disconnected in Settings. Create a new key or reconnect.
The model picks the wrong tool or stalls. Give it fewer tools (see Choosing a tool set) and include get_playbook.

Support: hello@mybazooka.com. Data handling for the connector is covered in section 10 of our privacy policy.