> For the complete documentation index, see [llms.txt](https://help.blotato.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://help.blotato.com/api/mcp/examples.md).

# Example Prompts

The Blotato MCP Server translates your natural language prompts into the right sequence of API calls. Here are common prompts and how they work behind the scenes.

## Prompt-to-Tool Mapping

| What You Say                                                                                                                  | Tools Called                                                                                                                                  | How It Works                                                                                                                                              |
| ----------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| "Post 'Hello world' to my Twitter"                                                                                            | `blotato_list_accounts` -> `blotato_create_post`                                                                                              | 2 calls. Finds your Twitter account ID, creates and publishes the post. Returns the published URL.                                                        |
| "Schedule a LinkedIn post for Friday at 3pm"                                                                                  | `blotato_list_accounts` -> `blotato_create_post`                                                                                              | 2 calls. Finds your LinkedIn account, creates the post with scheduledTime. Confirms the scheduled time.                                                   |
| "Summarize this YouTube video and post it to Instagram"                                                                       | `blotato_create_source` -> `blotato_list_accounts` -> `blotato_create_post`                                                                   | 3 calls. Extracts the video transcript, rewrites it for Instagram, then publishes with the right media type.                                              |
| "What accounts do I have connected?"                                                                                          | `blotato_list_accounts`                                                                                                                       | 1 call. Returns all connected accounts with subaccounts and platform details.                                                                             |
| "How many credits do I have left?"                                                                                            | `blotato_get_credits`                                                                                                                         | 1 call. Returns your remaining credits, account email, and current pricing.                                                                               |
| "Buy 5,000 credits"                                                                                                           | `blotato_get_credits` -> `blotato_buy_credits`                                                                                                | 2 calls. Confirms your account email, then returns a Stripe Checkout link to open and complete the purchase. Creating the link does not charge you.       |
| "Create an infographic about 5 AI trends"                                                                                     | `blotato_list_visual_templates` -> `blotato_create_visual`                                                                                    | 2 calls. Picks a suitable template, passes your prompt. AI fills in the content and layout.                                                               |
| "Make a carousel of motivational quotes"                                                                                      | `blotato_list_visual_templates` -> `blotato_create_visual` -> `blotato_get_visual_status`                                                     | 2-3 calls. Picks a carousel template, generates the visual. Polls for completion if needed.                                                               |
| "Generate a product showcase image for my new sneakers"                                                                       | `blotato_list_visual_templates` -> `blotato_create_visual`                                                                                    | 2 calls. Picks a template, passes your prompt with product details. Template AI handles layout and styling.                                               |
| "Create a short video about my coffee brand and post it to TikTok"                                                            | `blotato_list_visual_templates` -> `blotato_create_visual` -> `blotato_get_visual_status` -> `blotato_list_accounts` -> `blotato_create_post` | 4-5 calls. Full pipeline: pick video template -> generate video -> poll until done -> find TikTok account -> publish with the video URL.                  |
| "I want to make a quote card image"                                                                                           | `blotato_list_visual_templates` -> `blotato_create_visual`                                                                                    | 2 calls. Picks a quote card template, generates the image. Returns image URLs usable in a follow-up post.                                                 |
| "Check on my visual I created earlier"                                                                                        | `blotato_get_visual_status`                                                                                                                   | 1 call. Checks the status of a previous visual generation using its ID.                                                                                   |
| "Show me my scheduled posts"                                                                                                  | `blotato_list_schedules`                                                                                                                      | 1 call. Returns all future scheduled posts with their content, times, and target accounts.                                                                |
| "What did I publish on Instagram last week?"                                                                                  | `blotato_list_posts`                                                                                                                          | 1 call. Returns published Instagram posts in the time window with their public URLs.                                                                      |
| "Which of my Twitter posts failed this month?"                                                                                | `blotato_list_posts`                                                                                                                          | 1 call. Filters by `status=failed` and `platform=twitter`; returns each failure's `errorMessage`.                                                         |
| "Show me everything I posted or scheduled across all platforms recently"                                                      | `blotato_list_posts`                                                                                                                          | 1+ calls. Filters by `status=published,scheduled`; pages through results if there are many.                                                               |
| "Show me recent comments on my Instagram posts"                                                                               | `blotato_list_comments`                                                                                                                       | 1 call. Returns recent comments with their text, author, and status.                                                                                      |
| "Comment 'Thanks everyone!' on my latest Instagram post"                                                                      | `blotato_list_posts` -> `blotato_post_comment`                                                                                                | 2 calls. Finds your latest published Instagram post, then posts the comment on it.                                                                        |
| "Did my comment post yet?"                                                                                                    | `blotato_get_comment`                                                                                                                         | 1 call. Looks up the comment by its ID and returns its current status (queued, posted, or failed).                                                        |
| "What are my top posts this month?"                                                                                           | `blotato_list_top_posts`                                                                                                                      | 1 call. Returns your best published posts ranked by views (or another metric).                                                                            |
| "Get my top performing posts from last week and remix them into fresh viral ideas"                                            | `blotato_list_top_posts`                                                                                                                      | 1 call. Returns last week's strongest posts, then uses their topics and formats to propose new ideas.                                                     |
| "How is my latest Instagram post performing?"                                                                                 | `blotato_list_posts` -> `blotato_get_post_analytics`                                                                                          | 2 calls. Finds the published post, then returns its full metrics and history.                                                                             |
| "Fetch all the comments from my last 5 Instagram posts, summarize what people think, and recommend what I should post next"   | `blotato_list_posts` -> `blotato_list_comments`                                                                                               | 6 calls. Finds the five posts, reads their comments, summarizes sentiment and themes, then recommends content ideas.                                      |
| "Find the positive-sentiment comments on my last 10 Facebook posts and draft a reply to each one saying, 'I'd love to chat!'" | `blotato_list_posts` -> `blotato_list_comments`                                                                                               | 11 calls. Finds the posts, reads their comments, classifies sentiment, and drafts replies for your review without sending them.                           |
| "Show me my recent Instagram conversations"                                                                                   | `blotato_list_conversations`                                                                                                                  | 1 call. Returns your direct-message conversations, most recent first.                                                                                     |
| "Reply 'Thanks!' to my latest message from @jamie"                                                                            | `blotato_list_messages` -> `blotato_send_message`                                                                                             | 2 calls. Finds the conversation and the sender's id, then sends the reply.                                                                                |
| "Reschedule my LinkedIn post to Friday at 5pm"                                                                                | `blotato_list_schedules` -> `blotato_update_schedule`                                                                                         | 2 calls. Lists schedules to find the LinkedIn post, then updates its scheduled time.                                                                      |
| "Delete my scheduled Twitter post"                                                                                            | `blotato_list_schedules` -> `blotato_delete_schedule`                                                                                         | 2 calls. Lists schedules to find the Twitter post, then deletes it and cancels the publishing job.                                                        |
| "Change the text on my next scheduled Instagram post"                                                                         | `blotato_list_schedules` -> `blotato_list_accounts` -> `blotato_update_schedule`                                                              | 3 calls. Lists schedules to find the post, fetches accounts for the required fields, then updates the draft content.                                      |
| "Analyze this article and turn it into a thread"                                                                              | `blotato_create_source` -> `blotato_list_accounts` -> `blotato_create_post`                                                                   | 3 calls. Extracts the article content, splits it into thread segments, publishes as one thread using additionalPosts\[].                                  |
| "Remix this YouTube video into a fresh post"                                                                                  | `blotato_create_source` -> `blotato_list_accounts` -> `blotato_create_post`                                                                   | 3 calls. Extracts the video transcript (YouTube or TikTok, English captions only), the AI tool adapts it into a new post, then publishes or schedules it. |
| "Post this update to my Sunrise Bakery Facebook page"                                                                         | `blotato_list_accounts` -> `blotato_create_post`                                                                                              | 2 calls. Lists all accounts and subaccounts, matches "Sunrise Bakery" Facebook page, publishes with the correct pageId.                                   |
| "Upload this photo from my desktop and post it to Instagram"                                                                  | `blotato_create_presigned_upload_url` -> `blotato_list_accounts` -> `blotato_create_post`                                                     | 3 calls. Gets a presigned upload URL, uploads the local file, then publishes using the returned public URL. No Google Drive or S3 needed.                 |
| "Walk me through how to set up a Blotato DM Automation"                                                                       | `blotato_list_accounts` -> `blotato_create_automation`                                                                                        | The AI tool asks for the account, trigger, optional keywords, message, and links before creating the automation.                                          |

***

## Multi-Step Workflows

### Repurpose a YouTube Video to Multiple Platforms

> "Take this YouTube video \[URL], summarize it, create a carousel, and post it to Instagram and LinkedIn"

1. `blotato_create_source` - extracts the video transcript
2. `blotato_list_visual_templates` - finds carousel templates
3. `blotato_create_visual` - generates the carousel from the summary
4. `blotato_get_visual_status` - waits for the carousel to finish
5. `blotato_list_accounts` - finds your Instagram and LinkedIn accounts
6. `blotato_create_post` (x2) - posts to both platforms

### Schedule a Week of Content

> "Create 5 different quote cards and schedule them to my Twitter, one per day starting Monday"

1. `blotato_list_visual_templates` - finds quote card templates
2. `blotato_create_visual` (x5) - generates 5 quote cards with different prompts
3. `blotato_get_visual_status` (x5) - waits for each to finish
4. `blotato_list_accounts` - finds your Twitter account
5. `blotato_create_post` (x5) - schedules each with a different scheduledTime

### Review and Reschedule Content

> "Show me everything I have scheduled for this week. Move anything on Monday to Tuesday instead."

1. `blotato_list_schedules` - fetches all future scheduled posts
2. AI filters for posts scheduled on Monday
3. `blotato_update_schedule` (xN) - updates each Monday post's scheduledTime to Tuesday at the same time

### Upload a Local File and Post It

> "Post this video on my desktop to TikTok and Instagram"

1. `blotato_create_presigned_upload_url` - gets a presigned URL for the file
2. AI uploads the file to the presigned URL via HTTP PUT
3. `blotato_list_accounts` - finds your TikTok and Instagram accounts
4. `blotato_create_post` (x2) - posts to both platforms using the public URL from step 1

No need to upload the file to Google Drive or S3 first. The presigned URL lets you upload directly to Blotato.

### Research and Publish

> "Research the latest AI trends and create a thread about it on Twitter"

1. `blotato_create_source` - uses perplexity-query to research the topic
2. `blotato_list_accounts` - finds your Twitter account
3. `blotato_create_post` - publishes as a thread using additionalPosts\[] for the additional tweets

### Triage new comments and DMs

> "Show me every new comment and DM I have not answered since yesterday"

1. `blotato_list_comments` - lists recent comments filtered by `since`. Audience comments have `isAuthor: false`.
2. `blotato_list_conversations` - lists your recent DM threads.
3. `blotato_list_messages` - lists recent messages filtered by `since`. Incoming messages have `direction: incoming`.
4. AI groups the results into questions, positive replies, and action items, then drafts suggested responses.

This recipe reads only and sends nothing.

### Reply to comments on a post

> "Reply to every unanswered comment that expresses interest in my business on my latest Instagram post with a link to my website."

1. `blotato_list_posts` - finds your latest published post and its `postId`.
2. `blotato_list_comments` - lists the post's comments (`postId`, `isAuthor: false`).
3. `blotato_post_comment` - posts a reply to each comment with `parentCommentId` set to the comment ID.
4. `blotato_get_comment` - polls each reply until its status reaches `posted` or `failed`.

Blotato posts top-level comments and one level of replies. You reply to a top-level comment (a comment without a `parentCommentId`), not to a reply.

### Turn a comment keyword into a private reply (comment-to-DM)

> "When someone comments PRICE on my product post, send them the link in a private reply"

Set up a DM automation once, and Blotato watches the post and answers every matching comment on its own. You do not run a workflow per comment.

1. `blotato_list_accounts` - finds the Instagram account (for Facebook, also grab the `pageId` from its subaccounts).
2. `blotato_create_automation` - creates the automation with a `comment-received` trigger, `keywords: ["PRICE"]`, the `dmMessage`, and one link button. Pass `isActive: true` to publish it.
3. `blotato_get_automation_analytics` - checks how many times it fired.
4. `blotato_list_automation_runs` - lists individual runs and the error on each failure.

To watch one specific post instead of every post, pass its Blotato `postId` in the trigger. Get it from `blotato_list_posts`. To answer keyword DMs instead of comments, use a `message-received` trigger.

Restrictions to keep in mind:

* Instagram and Facebook allow one private reply per comment, within 7 days of the comment. If you've already privately replied to the comment (e.g. through another API or automation platform) your message will be rejected.
* After the private reply, you reach the person again only after they message you and open a new 24-hour messaging window.
* Automation buttons are link buttons only. For postback buttons or quick replies, send the message yourself with `blotato_send_message`.
* Per-post targeting uses a Blotato post ID, so it works on posts published through Blotato. For a post published elsewhere, watch any post and rely on keywords.
* Your own comments and the messages your account sends never trigger a run.
* Each new person the automation reaches counts toward your plan's monthly active-contacts limit (Starter 1,000, Creator 6,000, Agency 15,000). See [Active Contacts](/settings/billing-and-credits.md#active-contacts).

See [DM Automations](/features/dm-automations.md).

### Answer DMs from your inbox

> "Draft replies to anyone asking about shipping in my Instagram DMs"

1. `blotato_list_conversations` - lists your DM threads.
2. `blotato_list_messages` - lists incoming messages (`direction: incoming`), filtered by conversation or account.
3. AI drafts a reply from your FAQ for each unanswered message.
4. `blotato_send_message` - sends each reply. Set `recipientId` to the incoming message's `senderId`.
5. `blotato_get_message` - poll each reply until its status reaches `sent` or `failed`.

Restrictions to keep in mind:

* You reply to a standard DM within 24 hours of the person's last message. Blotato does not support cold outreach to people who have not messaged you.
* Each new person you message counts toward your plan's monthly active-contacts limit (Starter 1,000, Creator 6,000, Agency 15,000). See [Active Contacts](/settings/billing-and-credits.md#active-contacts).
* To draft replies without sending, skip the `blotato_send_message` step.

### Offer buttons or quick replies in a DM

> "Reply to this DM with three options: Small, Medium, Large"

1. `blotato_list_messages` - finds the incoming message and its `senderId`.
2. `blotato_send_message` - sends the reply with `quickReplies` set to the three chips, each with a `title` and a `payload`.
3. `blotato_list_messages` - reads the next incoming message and its `payload.selection.payload` to see the choice.

Swap `quickReplies` for `buttons` to pin up to 3 call-to-action buttons under the message instead. Use `type: "web_url"` to open a link, or `type: "postback"` to capture the tap.

Restrictions to keep in mind:

* Buttons and quick replies are mutually exclusive. Sending both is rejected.
* Instagram renders buttons in the Instagram mobile app only. A recipient reading the conversation on instagram.com in a desktop browser sees the message text with no buttons. Pass `buttons` or a URL inside `text`, not both, since a message carrying both leaves the URL unclickable on desktop.
* Buttons cap the message text at 640 characters. Quick replies require non-empty text.
* Button and chip labels are limited to 20 characters.
* Blotato subscribes your account to the postback webhook when you connect it. If you connected your account before buttons were launched, [reconnect](https://my.blotato.com/settings) to start receiving postback events.

See [Buttons and Quick Replies](/api/mcp/tools.md#buttons-and-quick-replies).

***

## Combining Canva and Blotato

If you have both the [Canva](https://www.canva.com/help/mcp-agent-setup/) and Blotato MCP connectors enabled in your AI coding agent (Claude, Cursor, Codex, Cline, or another MCP-compatible client), use these prompts to bridge them.

For a full walkthrough of combining Canva, Claude, and Blotato, watch this tutorial: [Canva + Claude + Blotato](https://youtu.be/MQjCyQBRZ_M).

### Post Canva designs to social media

> "Export from Canva and then pass the Canva export domain URLs directly to Blotato to post."

The AI agent exports your Canva design, captures the public Canva CDN URL, and passes it straight into `blotato_create_post` as a `mediaUrl`. No download or re-upload required.

### Use your own photos or videos inside a Canva design

> "Use Blotato to upload the photos so Canva can use them."

The AI agent calls `blotato_create_presigned_upload_url` to upload each local file to Blotato, then hands the resulting public URLs to Canva as image assets. From there, Canva imports the URLs into your design.

### Posts failing with "Could not fetch media"

This error means Blotato was unable to download the image URL passed in `mediaUrls` at publish time. In n8n it usually surfaces as `Failed to fetch media URL: char '<X>' is not expected.:1:1` together with `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.` -- the character in the error is the first character of whatever text the remote URL returned (e.g. `e` for "expired" or "error..."). Open `{error}.$response` in n8n to read the actual body. Common causes:

* The URL is signed and expired before Blotato fetched it (Canva exports, S3 presigned URLs, Google Drive `/view` links)
* The URL points to a preview page or folder, not a direct image file
* The image is behind a login or CDN bot protection

Different case -- the media was generated BY Blotato: if the failing URL points to Blotato's own hosting (for example a `...r2.dev/pipeline/...` or `database.blotato.io` link) and a plain retry sometimes publishes the same post with no changes, the cause is a Blotato-side media fetch timeout (most common with larger files), not your URL or your workflow. Retry the post from [Failed Posts](https://my.blotato.com/failed), and contact support in the in-app chat if the same post keeps failing after several retries.

How to fix it:

1. If your AI agent generated images in Canva, send it the two prompts above so it passes the Canva export URL directly into `mediaUrls` instead of trying to download and re-upload.
2. If you used Google Drive, use a direct-download URL in this format: `https://drive.usercontent.google.com/download?id=FILE_ID&export=download&confirm=t`
3. If you have a local file, use Blotato's presigned upload flow to host the file on Blotato first, then publish using the returned `publicUrl`. See: [Upload Media](/api/publish-post/upload-media-v2-media.md#presigned-upload-local-files)
4. Test 1 post first before scheduling a batch.

Platform-specific note: Pinterest is limited to 10 pins per day per account, so a large batch will hit the platform limit even with valid media. See: [Pinterest Limits](/settings/social-accounts.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://help.blotato.com/api/mcp/examples.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
