MCP App Store
by KeenEthics
Spredo icon

Spredo MCP Server for ChatGPT

By Spredo Ltd.

Overview

Connect Spredo to ChatGPT to manage your entire B2B sales workflow on Telegram without leaving your chat. Spredo is an AI-powered sales platform with 300,000+ Web3 and 60,000+ iGaming business contacts, 30+ targeting filters, automated Telegram outreach, and a built-in CRM. Find and validate decision-makers, create campaigns, generate personalized messages, launch outreach, manage conversations and follow-ups, and analyze campaign performance — all through natural language. Spredo MCP works with your existing workspace permissions and is equipped with platform documentation and outreach best practices. Ideal for business development, partnerships, lead generation, and sales teams operating in Web3 and iGaming.

How to connect

  1. ChatGPT: Open the Spredo listing in the ChatGPT app directory and choose Connect. ChatGPT listing Spredo exposes 83 tools here.

Tools

add_message_templates

ChatGPT
Add one or more cold-message template variants to a campaign. Each template is copy that may contain {placeholder} variables filled per lead at generation time. Supported placeholders: {company}, {company_token}, {company_website}, {company_description}, {company_focus}, {company_type}, {company_blockchains}, {company_telegram}, {company_x}, {company_linkedin}, {company_location}, {person_telegram}, {person_x}, {person_linkedin}, {person_linktree}, {person_title}, {person_first_name}, {person_location}, {person_linkedin_connections}, {person_x_followers}, {person_x_creation_date}, {client_custom_info}, {client_company}, {session_username}, {account_name}. Any other placeholder is rejected with 400 — nothing else can be filled per lead. {person_first_name} and {account_name} are translated to the campaign's target language; the rest are substituted verbatim. A line reading <split> cuts the text into separate Telegram messages (at most 3); the parts go out a few seconds apart, as if typed, with the delay chosen automatically. Generation keeps the split where the template put it. Run generate_messages afterwards for new templates to reach leads.

add_sequence_step

ChatGPT
Add a follow-up step (a 'ping') to a sequence. content is the message copy and may use the same {placeholders} as campaign templates — unknown placeholders are rejected with 400. delay_hours is the wait after the previous step (24–720 hours; for the first step it counts from the lead's initial cold message). step_index is 0-based and must be free in this sequence — pass the current step count from get_sequence to append at the end (a taken index fails with 409). Steps go out in step_index order. On a running sequence, dialogues that have not passed the new position pick it up automatically; dialogues that had already finished the sequence get it only after start_sequence is called again.

archive_message_template

ChatGPT
Archive or restore a campaign template (is_archived). An archived template stops being used by generate_messages and by import_message_templates_from_campaign, but keeps its stats and its already-generated messages. Use this instead of deleting a template that has already been sent.

assign_chat_label

ChatGPT
Assign an existing label (label_id) to a dialog (chat_id + campaign_id). Idempotent.

count_companies

ChatGPT
Count of distinct companies matching the COMPANY filters only (user/other filters are ignored) that have at least one reachable contact — companies nobody works at are never counted. This is still NOT how many contacts you can reach: it counts companies, not people, and ignores the user filters. For the real reachable audience use count_matched_contacts.

count_matched_contacts

ChatGPT
The REAL number of reachable contacts: the merged/matched user<->company set after applying ALL filters. Cheap (no enrichment), so prefer it over preview_contacts when you only need the count. Often much smaller than count_users / count_companies, which are per-entity counts that overstate reach. Call this before preview_contacts.

count_users

ChatGPT
RAW count of distinct users (people) matching the USER filters only (company/other filters are ignored). This is NOT how many contacts you can reach: it does not merge people with their companies. For the real reachable audience use count_matched_contacts.

create_campaign

ChatGPT
Create a new, empty, inactive campaign and return it with its id. Typical next steps: import leads (insert_leads), add templates (add_message_templates), generate messages (generate_messages), then activate with update_campaign_status.

create_chat

ChatGPT
Start a brand-new Telegram conversation with a lead (by username) and send the first message from a campaign account. This performs a REAL Telegram send — confirm with the user first. Fails if the lead is already in the campaign. CREDIT-CONSUMING when sent from a Spredo-provided account — this IS a lead's first cold message, so it spends 1 messages_credit and is refused at a zero balance (check it via get_client_data). From an account the client connected themselves (origin: client on get_accounts) it is free, subject to a monthly per-account ceiling. Messaging an existing dialog with send_message is always free.

create_filter_preset

ChatGPT
Save a contacts-selection filter set as a named preset for reuse (name, optional industry, and the filter list).

create_followup

ChatGPT
Schedule a follow-up message for a dialog (this is how a follow-up date is set). Requires campaign_id, chat_id, session_id (account id), the message text, and a future scheduled_time. The message is sent automatically at that time — confirm the text and time with the user first. Consumes NO credits — only a lead's first cold message is charged.

create_group_chat

ChatGPT
Create a REAL Telegram group chat with the given members (usernames) from a campaign account — confirm with the user first.

create_label

ChatGPT
Create a new inbox label for a client. color must be a hex string like #1A2B3C.

create_sequence

ChatGPT
Create the cold sequence for a campaign (campaign_id + name). It starts PAUSED, with no steps and the default schedule (weekdays [0, 1, 2, 3, 4] where 0=Monday, 07:00–19:00 UTC): add steps with add_sequence_step, adjust the schedule with update_sequence_schedule / update_sequence_settings, then start_sequence. A campaign runs a single sequence — this fails with 409 if one already exists (see get_sequences). To reuse copy that already works in another campaign, call import_sequence instead.

create_upload

ChatGPT
Step 1 of sending a file into a dialog: declare the file (name, exact size in bytes, MIME type) and get back an upload_url and an upload_id. Step 2: PUT the file's bytes to upload_url over plain HTTP (no auth header; e.g. curl -X PUT --upload-file <path> <upload_url>). Step 3: call send_message with that upload_id (and no file); the file is then sent in the background, so poll get_upload_status. Nothing is sent to Telegram by this call itself. For a client that cannot make HTTP requests, send_message also takes a small file inline as base64.

delete_filter_preset

ChatGPT
Delete a saved filter preset by preset_id.

delete_followup

ChatGPT
Cancel/delete a scheduled follow-up by followup_id.

delete_label

ChatGPT
Delete a label by id, removing it from every dialog it was assigned to.

delete_leads

ChatGPT
Remove leads from a campaign by their lead ids. Leads that have already been messaged cannot be removed (the request fails and reports them). Also deletes the removed leads' generated messages.

delete_message_template

ChatGPT
Delete a template from a campaign by template_id. Only possible while nothing has been generated from it — after that the call fails and you must call archive_message_template instead, which keeps the template's messages and stats. Does not affect already-generated messages.

delete_sequence_step

ChatGPT
Remove a step from a sequence (step_id from get_sequence). Dialogues that have not reached it yet simply skip it, and the other steps keep their step_index (gaps are fine). Dialogues currently WAITING on this step are left without a next ping, so on a running sequence prefer update_sequence_step to rewrite the copy instead.

edit_message

ChatGPT
Edit the text of a message already sent in a dialog. This edits the REAL Telegram message — confirm the new text with the user first.

export_contacts

ChatGPT
Export the contacts matched by a filter audience to a CSV and return a signed download URL (valid ~1 hour). CREDIT-CONSUMING — spends 1 contacts_credit per exported contact (same shared pool as insert). The balance is checked BEFORE exporting and the call fails with HTTP 402 if insufficient. Before calling, check the balance via get_client_data (contacts_credits) and the count via count_matched_contacts, tell the user the cost, and confirm. Use limit to cap. Cherry-picking after a preview: pass included_user_ids to export ONLY specific contacts (use the user_id values from preview_contacts), or excluded_lead_ids to export everything matching the filters except those. Past exports are retrievable via list_exports_history / get_export_signed_url.

export_credit_preview

ChatGPT
What export_contacts would actually cost, WITHOUT charging or exporting anything. Free and side-effect-free. Takes the same body as export_contacts and returns {total, owned, chargeable}: total in-scope contacts, owned already paid for on some channel (free again — pay-once billing), and chargeable the credits that will really be spent. Call this before export_contacts and quote chargeable to the user — count_matched_contacts is only an upper bound on cost.

generate_ai_templates

ChatGPT
Use AI to draft new template variants for a campaign from a plain-English user_prompt, automatically adding them to the campaign. Consumes NO credits. Review the result with get_message_templates.

generate_messages

ChatGPT
Trigger AI generation of per-lead cold messages for a campaign from its templates. This runs an ASYNCHRONOUS job and consumes NO credits — generation is free; message credits are only spent later, when the campaign sends a lead's first cold message. Nothing after that first message is charged. Poll get_message_generation_status for progress. Requires the campaign to have templates and eligible leads (see get_eligible_leads_count_for_generation). Set regenerate=true to rebuild messages, which first DISCARDS the campaign's unsent generated messages; ones edited by hand are kept unless overwrite_edited=true is also set.

get_accounts

ChatGPT
Telegram sender personas used for outreach (NOT leads or workspace users). Pass either campaign_id (accounts on that campaign) or client_id (all workspace accounts) — neither = HTTP 400. active_only=true drops banned and revoked accounts. include_stats=true adds cached per-account campaign read/response stats when campaign_id is provided.

get_campaign

ChatGPT
Campaign metadata including accessors (team members with access). For performance use get_campaign_stats; for the inbox use get_dialogs. Automated cold sequences (the follow-up steps that go out after a lead's first cold message) are managed with the sequence tools — start from get_sequences. Sequence messages consume no message credits.

get_campaign_lead_insertion_log

ChatGPT
History of lead-import batches for a campaign: timestamp and number of leads inserted per batch, plus how the batch got there — contacts_selection batches carry the filters/industry used, manual_import batches (CSV upload or insert_leads) carry the skipped-row counts and the outcome of the background Telegram validation, and transfer batches carry how many of the copied leads the campaign already held.

get_campaign_leads

ChatGPT
Get a list of leads for a specific campaign.

get_campaign_leads_count

ChatGPT
Get the total lead count for a campaign without fetching the full payload.

get_campaign_stats

ChatGPT
Daily performance breakdown for one campaign, with optional start_date / end_date (ISO YYYY-MM-DD). Returns daily buckets of cold_messages_sent, messages_read, responded. Gotchas: total_sent is all-time and ignores the date filter (sum the buckets for a date-bounded total); responded counts replies received that day regardless of when the original send went out. For cross-campaign comparison prefer get_global_stats; for batched use get_campaign_stats_batch.

get_campaign_stats_batch

ChatGPT
Batched get_campaign_stats for up to 25 campaigns. Prefer over loops when comparing campaigns.

get_campaigns

ChatGPT
Lists all campaigns in the workspace including inactive ones (filter on is_active client-side). Use to discover campaign IDs.

get_client_data

ChatGPT
Workspace details — name, plan, credit balances, team members. Requires client_id (from get_me). Two SEPARATE credit pools (spending one never draws on the other; on Full Package a workspace admin can Rebalance them in Team Settings, re-splitting the total at 1 contact credit = 2 message credits; credits_alert says when active campaigns would run out of message credits — rebalance if Rebalance covers them, top_up if not): contacts_credits (1 per contact acquired via insert_to_campaign / export_contacts / reveal_contact — pay-once per contact, free forever after on every channel) and messages_credits (INITIAL-MESSAGE credits: charged for a lead's first cold message, whichever account it goes out from; the one free first message is create_chat from an account the client connected themselves). Everything Spredo sends after that first message is free — cold sequence steps, follow-ups, and every later message in a dialogue consume no message credits. The balance never goes below zero: create_chat from a Spredo-provided account is refused once it reaches 0.

get_contact_filter_options

ChatGPT
Allowed values for a single select/multiSelect contact filter, identified by its filter_slug from list_contact_filters. Returns an empty list for filters that have no fixed option set (free text/numeric/range/boolean). When building that filter, use ONLY these exact strings as the InputFilter value.

get_dialogs

ChatGPT
Inbox conversations for given campaign_ids. Each entry's id is the chat_id — pair with campaign_id and account_id to fetch messages.Filters: active_only=true returns only dialogues where the lead has replied (has_initial_response=true) — the right default for "engaged" / "replied" / "active" prompts. unread_only=true returns dialogues with unread messages or a manual unread mark (marked_unread). No pagination or other filters.

get_eligible_leads_count_for_generation

ChatGPT
Number of leads currently eligible for message generation in a campaign (live DB count, not a job snapshot). Eligibility = belongs to the campaign, initial message not yet sent, has enrichment data, no generated message yet.

get_export_signed_url

ChatGPT
Get a fresh signed download URL for a past export by log_id (from list_exports_history). Does not consume credits or re-export.

get_followups_for_chat

ChatGPT
List scheduled follow-ups for a dialog (campaign_id + chat_id + session_id/account id).

get_generated_messages

ChatGPT
Per-lead first cold messages with placeholders rendered. Use to inspect personalization quality before launch or to see what a specific lead received as their first touch. Distinct from get_message_templates (unrendered source) and get_messages (full conversation including replies).

get_global_stats

ChatGPT
Precomputed performance rollup across ALL the client's campaigns — one row per campaign with reply rate, sent today / yesterday / last_week / total, and progress vs. plan. Fastest tool for cross-campaign comparison. Does NOT support custom date ranges — use get_campaign_stats for that.

get_importable_sequences

ChatGPT
Sequences in the user's other campaigns that import_sequence can copy into target_campaign_id: id (use it as source_sequence_id), name, campaign_name and total_steps. The target campaign's own sequence is excluded.

get_labels

ChatGPT
List all inbox labels for a client (client_id). Use to discover label ids before assigning.

get_me

ChatGPT
Returns the authenticated user, including client_id (required by get_client_data and get_accounts), client_plan (full_package / crm_only / data_only — data_only clients can't access campaign tools) and read_only (true for the viewer workspace role: every write tool answers 403, report it and don't retry). Call first.

get_message_generation_status

ChatGPT
Status of the latest message generation job for a campaign. Returned status is one of queued, running, completed, failed, or null if no job has ever been created for the campaign.

get_message_templates

ChatGPT
Reusable cold-message copy variants for one campaign, with {person_first_name} / {company} placeholders intact. Each template also carries how it performed: sent (chats it cold-messaged), read_rate and reply_rate in percent — use these to tell a client which copy works and which to rewrite. They are absent for templates that have not been sent yet, and for everything generated before attribution existed. is_archived marks templates taken out of rotation, can_delete is false once a template has generated anything — archive those instead. For the rendered per-lead messages, use get_generated_messages.

get_messages

ChatGPT
Full message history of one chat (oldest first). Requires the triple campaign_id + account_id + chat_id, all available together in get_dialogs. Distinct from get_generated_messages (rendered first message only, no replies). Text may contain HTML entities. Prefer get_messages_batch over loops.

get_messages_batch

ChatGPT
Batched get_messages for up to 25 chats. Prefer over loops.

get_sequence

ChatGPT
One sequence with its ordered steps (id, step_index, content, delay_hours — hours to wait after the previous step; for the FIRST step it is counted from the lead's initial cold message, not from when the sequence started). New or changed delays must be within 24–720 hours: pinging a lead again within a day of the cold message is what gets a sending account frozen by Telegram. Steps created before that rule keep their stored delay until it is edited. sequence_id comes from get_sequences. Edit the steps with add_sequence_step / update_sequence_step / delete_sequence_step (they take the step id from here). Sending these steps consumes no message credits.

get_sequence_accounts_stats

ChatGPT
Per-account throughput for a sequence: daily_sent_messages against daily_limit, active_dialogues / completed_dialogues, and whether the account is in is_cooldown (with cooldown_seconds left). Use this to explain why a sequence is sending slowly or not at all — accounts at their daily limit or in cooldown are skipped until the next window.

get_sequences

ChatGPT
Automated cold sequences for a campaign, with progress stats. A sequence is the chain of follow-up steps that goes out after a lead's FIRST cold message, on a schedule (weekdays, time_window_start_utc/_end_utc, all UTC), stopping for a lead as soon as they reply. Sequence messages consume NO credits — only the first cold message to a lead is charged. A campaign runs a single sequence (create_sequence and import_sequence refuse a second one), so this normally returns zero or one item. Per sequence you get total_steps, active_dialogues (still enrolled), completed_dialogues, messages_sent / total_possible_messages and progress; is_active is the run switch (start_sequence / stop_sequence) and only_unread means it drops dialogues whose previous message was already read (update_sequence_settings). Use get_sequence for the step copy and delays.

get_spredo_guide

ChatGPT
Spredo's product guide, in the version for the user's plan: how each feature works, launching a first campaign, getting 30%+ reply rates, Telegram accounts, message templates, sequences, follow-ups, CRM integration, team roles and credits. Read it before answering any question about how Spredo works or how to get better results with it, and answer from it rather than from memory. Without topic it returns the guide's map, which lists a topic per guide (e.g. our-credit-system); pass one as topic to read that guide. Free, and it reads nothing from the workspace.

get_upload_status

ChatGPT
Poll best-effort media upload progress for an in-flight send_message, keyed by the upload_id the client generated. Returns {status, sent, total}; status=unknown when not (yet) tracked.

grant_campaign_access

ChatGPT
Grant the given user emails access to a campaign. Caller must be a client admin. Idempotent — emails that already have access are skipped.

import_generated_messages

ChatGPT
Attach client-written first cold messages to leads already in a campaign, matching each row to a lead by Telegram handle (person_telegram). Use when the client wrote the copy themselves instead of generating it from templates: an imported lead is skipped by generate_messages, and a campaign whose every unmessaged lead has an imported message can start with no templates at all. Rows per call are capped at the same limit as insert_leads, and each text is at most 4096 characters. Text is stored and sent VERBATIM — {placeholder} variables are NOT substituted. Free — consumes no credits. A lead's existing unsent message is replaced — uploading a file of messages means "use this text". Handles not in the campaign and leads already messaged are skipped and reported back per bucket.

import_message_templates_from_campaign

ChatGPT
Copy the active message templates from one campaign into another (source_campaign_id → target_campaign_id); you need access to both. Archived templates are skipped — they were taken out of rotation on purpose. Appends to the target's existing templates (does not replace). Free — consumes no credits. Run generate_messages on the target afterwards for the copied templates to reach its leads.

import_sequence

ChatGPT
Copy a sequence — steps, delays, schedule and only_unread — from another campaign into target_campaign_id under a new name. source_sequence_id comes from get_importable_sequences. The copy lands PAUSED with nobody enrolled, so review it with get_sequence and then start_sequence. Source delays outside 24–720 hours are clamped into that range on the way in. Fails with 409 if the target campaign already has a sequence.

insert_credit_preview

ChatGPT
What insert_to_campaign would actually cost, WITHOUT charging or inserting anything. Free and side-effect-free. Takes the same body as insert_to_campaign and returns {total, owned, chargeable}: total in-scope contacts, owned already paid for on some channel (free again — pay-once billing), and chargeable the credits that will really be spent. Call this before insert_to_campaign and quote chargeable to the user — count_matched_contacts is only an upper bound on cost.

insert_leads

ChatGPT
Import leads into a campaign (up to 10,000 per call). Each lead needs a person_telegram handle or, failing that, a person_phone; with both, the handle wins and the number is only stored, and a junk handle (n/a, -) falls back to the number instead of failing the row. Phone numbers must start with + and the country code (+14155550123) — a number without it is skipped and reported, never guessed at. A phone-only lead is looked up on Telegram by the background validation job, which writes the handle it resolves onto the lead; a lead whose handle turns out to be dead also falls back to its number, and the handle that resolves replaces the dead one. A number that resolves to nobody, or to somebody who has no @username, leaves a lead nothing can ever address, so that lead is removed — the same as an unreachable handle. Note that Telegram answers PHONE_NOT_OCCUPIED both for a number nobody is behind and for one the asking account is not allowed to look up, and the two are indistinguishable, so a number that fails here is not proof the person is not on Telegram; re-uploading the same file later retries it. Other company/person fields are optional and feed template placeholders. Set exclude_existing_across_client=true to skip usernames already present in the client's other campaigns; a phone number is only ever matched against the target campaign, since the rename that repairs such a match is campaign-scoped too. One account never holds the same person in two campaigns of the workspace: a lead is given an account that does not already hold that person elsewhere, and one no account of the campaign can take is skipped and reported in the message. Re-running refreshes existing rows with new field values. Each lead may also carry an optional initial_message — a ready-made first cold message stored for that lead, which spares it AI generation, and which works on phone-only leads too (it is kept through validation and stays with the lead once its handle is resolved); for leads already in a campaign use import_generated_messages instead.

insert_to_campaign

ChatGPT
Insert the contacts matched by a filter audience into a campaign as leads (full_package plan only). CREDIT-CONSUMING — spends 1 contacts_credit per inserted lead. Before calling, check the balance via get_client_data (contacts_credits) and the audience size via count_matched_contacts, tell the user the credit cost, and confirm. Deduction happens AFTER insertion, so an unbounded audience can overspend (balance goes negative) — prefer setting limit to cap how many are inserted. Rate-limited per day. Cherry-picking after a preview: pass included_user_ids to insert ONLY specific contacts (use the user_id values from preview_contacts), or excluded_user_ids to insert everything matching the filters except those user_ids.

list_contact_filters

ChatGPT
List the contact filters available to YOU (filtered by your role and, if industry is given, that industry). Each entry has slug, label, group, type, available_operators, and optional modifiers. The options field is NOT inlined here — for select/multiSelect filters call get_contact_filter_options(slug) to fetch the allowed values. Build filters using the exact slug and operators from this list. Start here. Note: contact tools are blocked for clients on the crm_only plan.

list_exports_history

ChatGPT
History of past contact exports for a client (client_id): timestamp, number of records exported, and the filters/industry used per batch. Reading history does not consume credits.

list_filter_presets

ChatGPT
List your saved contacts-selection filter presets (named, reusable filter sets).

mark_as_read

ChatGPT
Mark all incoming messages in a dialog as read (also marks them read in Telegram) and clear its marked_unread mark.

preview_contacts

ChatGPT
Sample of the matched contacts (merged user<->company rows) plus the true total matched count. Pass a small limit (5-20) — rows carry many dynamic enrichment columns, so large previews are heavy. total is the full matched count regardless of limit. Non-admin callers see social/contact columns returned as '<REDACTED>', EXCEPT on rows flagged is_owned: true (already paid for on some channel — those come back unblurred and cost nothing again). To unblur one specific redacted row, call reveal_contact with the same filters and that row's user_id (1 credit). Use count_matched_contacts first if you only need the number. Page through the sample with offset — the preview covers the first 2000 matched contacts.

remove_campaign_access

ChatGPT
Remove the given user emails' access to a campaign. Caller must be a client admin.

rename_campaign

ChatGPT
Rename an existing campaign by campaign_id.

report_feedback

ChatGPT
Tell the Spredo team about a problem with these tools: a tool that errored or misbehaved, a capability the user needed that no tool offers, a description that misled you, or data that looks wrong. Call it once per problem, then carry on or tell the user. It is free, has no effect on the workspace, and is read by Spredo engineers. Do not report expected refusals (a plan restriction, a view-only role, a zero credit balance) and do not paste message text, lead handles or phone numbers.

reveal_contact

ChatGPT
Unblur ONE contact from a preview, in place. CREDIT-CONSUMING — spends 1 contacts_credit, from the same shared pool as insert/export, unless the client already owns the contact (pay-once), in which case it is free. Pass the SAME filters (and industry) you previewed with, plus one user_id taken from a preview_contacts row; returns that single contact with its social/contact columns unredacted. Rows that came back with is_owned: true are already unblurred and need no reveal. Use this when the user wants to see one specific contact — it is much cheaper than exporting the whole audience. Tell the user the 1-credit cost and confirm before calling.

send_message

ChatGPT
Send a Telegram message in an existing dialog. This performs a REAL Telegram send from the campaign account — confirm the recipient and exact text with the user first. Identify the dialog (chat_id + account_id) via get_dialogs. Consumes NO credits — only a lead's first cold message is charged, and this dialog already exists.

start_sequence

ChatGPT
Start or resume a sequence (is_active=true). It enrolls every dialogue in the campaign whose lead has never replied (only those whose last message is still unread when only_unread is on), revives dialogues that had finished the sequence when later steps were added since, and keeps the position of dialogues that were paused. The first ping is due the first step's delay_hours after the lead's last message — for older dialogues that is right away, in the next allowed schedule slot. With no steps nothing is enrolled, so add steps first. This begins REAL automated Telegram sends from the campaign's accounts — confirm with the user first. Consumes no credits. update_campaign_status with include_sequences=true toggles the sequence together with the campaign.

stop_sequence

ChatGPT
Pause a sequence (is_active=false): no further pings go out until start_sequence. Each dialogue keeps its position, so resuming continues where it stopped rather than repeating pings, but a ping left waiting for more than 30 days expires and that dialogue drops out of the sequence. Sequences also stop themselves once every enrolled dialogue has replied or finished.

unassign_chat_label

ChatGPT
Remove a label (label_id) from a dialog (chat_id + campaign_id). The label itself is not deleted.

update_campaign_status

ChatGPT
Start (is_active=true) or stop/pause (is_active=false) a campaign; a single flag drives the send loop, so stop and pause are the same operation. Activating requires that every lead already has a generated message, that the campaign still has unmessaged leads, that at least one active account is assigned to send from, and that the workspace still has initial-message credits left (messages_credits from get_client_data, charged once per lead first-contacted — not per message sent), otherwise it fails. Stopping is always allowed. Pass include_sequences=true to start/stop the campaign's follow-up sequences in the same call — otherwise they keep their own state (a running sequence keeps sending follow-ups while the campaign is paused). Starting a campaign begins REAL Telegram outreach — confirm intent with the user first.

update_chat_metadata

ChatGPT
Set local inbox metadata on a dialog: priority (high/medium/low) and marked_unread (true shows the dialog as unread without touching its messages' read state; mark_as_read clears it). Local CRM state only — does not change anything in Telegram. Muting moved to the per-user notification level and is not settable here.

update_filter_preset

ChatGPT
Update a saved filter preset by preset_id (any of name, industry, filters).

update_followup

ChatGPT
Update the message text of a scheduled follow-up by followup_id.

update_generated_message

ChatGPT
Edit the rendered first-cold-message text for a single lead (from get_generated_messages). A line reading <split> cuts the text into separate Telegram messages (at most 3); the parts go out a few seconds apart, as if typed, with the delay chosen automatically. Use to fix personalization before the message is sent: once it has gone out the edit is refused, because the lead is holding the text that was sent and rewriting it here would only hide that.

update_message_template

ChatGPT
Edit the text of an existing campaign template (by template_id from get_message_templates). A line reading <split> cuts the text into separate Telegram messages (at most 3); the parts go out a few seconds apart, as if typed, with the delay chosen automatically. Run generate_messages afterwards for the change to reach leads.

update_sequence_schedule

ChatGPT
Change when a sequence may send: weekdays (0=Monday … 6=Sunday; non-empty, no duplicates) and/or time_window_start_utc / time_window_end_utc (whole hours 0–24 in UTC, must differ; a start after the end is an overnight window). Omitted fields keep their current value. A ping that comes due outside the window simply waits for the next allowed slot — nothing is skipped.

update_sequence_settings

ChatGPT
Set only_unread. When true the sequence only pings leads who have NOT read the previous message: a dialogue whose last outgoing message is already read is dropped from the sequence at its next ping instead of being messaged, and is not enrolled in the first place. Applies from the next scheduled ping; switching it off does not re-enroll dialogues that were already dropped.

update_sequence_step

ChatGPT
Edit a step's content and/or delay_hours (step_id from get_sequence). The body is the whole step, so pass its current step_index back unchanged — reordering is not supported; delete and re-add instead. A changed delay must be within 24–720 hours (re-submitting an older, shorter stored delay unchanged is allowed) and shifts the due time of dialogues currently waiting on this step by the difference. New copy applies to every send from now on; pings already sent are not touched.

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/spredo"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/spredo)