Schedule social posts from Muse

# posterly for Muse

posterly is the publish layer. Muse is the chat layer. Add a Custom Connector with OpenAPI and a Bearer key. Hosted MCP is optional. Directory approval has not been confirmed. posterly is not listed in the Muse directory yet.

posterly publishes to 18 platforms: Instagram, Facebook, TikTok, X, LinkedIn, YouTube, Pinterest, Threads, Google Business, Telegram, Bluesky, Discord, Slack, Mastodon, Dev.to, Hashnode, WordPress, Lemmy.

## Connect

Use Muse Custom Connector. Do not treat posterly as a listed Muse directory app. Directory approval has not been confirmed. posterly is not listed yet.

Primary contract: OpenAPI plus a Bearer API key.

- OpenAPI: https://www.poster.ly/api/openapi
- Interactive API reference: https://www.poster.ly/reference
- Agents overview: https://www.poster.ly/agents
- Muse Custom Connector page: https://www.poster.ly/muse

Auth (primary):
- After paid signup, the user copies a Bearer key that starts with pst_live_ from Dashboard, API and MCP.
- Header: Authorization: Bearer pst_live_...
- Prefer OAuth if Muse Custom Connector accepts https://www.poster.ly/.well-known/oauth-protected-resource and https://www.poster.ly/.well-known/oauth-authorization-server.
- Never invent keys. Never collect card details, posterly passwords, or social-network passwords.

Optional secondary: hosted MCP, only if Muse Custom Connector accepts JSON-RPC over a single POST.

- MCP setup: https://www.poster.ly/mcp
- Hosted MCP endpoint: POST https://www.poster.ly/api/mcp
- MCP server card: https://www.poster.ly/.well-known/mcp/server-card.json
- MCP OAuth resource: https://www.poster.ly/.well-known/oauth-protected-resource/api/mcp
- Wire format: JSON-RPC 2.0 over a single POST. No SSE and no streamable HTTP in v1.
- GET https://www.poster.ly/api/mcp returns server info without auth.
- If Muse Custom Connector requires streamable HTTP, do not pretend hosted MCP works. Stay on the OpenAPI connector and tell the user about this gap.

What you can do through the posterly API:
- List connected social accounts
- Schedule posts after the user confirms the exact caption, account, media, and time
- Create browser connect sessions so the user authorises Instagram, Meta, YouTube, LinkedIn, X, and the rest in their own browser

Approval gates:
- Call whoami, then list accounts
- Prefer validate_post or REST dry_run: true first
- Show the preview
- Wait for an explicit yes
- Only then call create_post with confirm: true, or make the live REST request
- Publish and go-live always need that confirmation
- Social account connect stays in the browser via connect sessions (POST /api/v1/connect/{platform}/sessions). Poll GET /api/v1/connect/sessions/{id}
- Do not invent Autopilot behaviour or prices

Signup and Stripe:
- Start paid access with POST /api/v1/signup or send the user to https://www.poster.ly/agents/signup
- Signup uses the existing posterly Stripe checkout handoff. No API key before billing is active.
- API and MCP access is an add-on ($3/month Starter/Pro, $5/month Power, or $29/month Agency) on a paid plan.

Hosted MCP exposes 61 tools covering 97 actions when the optional JSON-RPC POST transport is accepted. Do not scrape the dashboard. Use OpenAPI, the reference, or list_platforms.

Chat attachments never reach posterly. If Muse requires streamable HTTP or SSE, stay on the OpenAPI connector.

## Are we connected yet?

1. Call `whoami` (no params). Confirm the user, scopes, and workspaces.
2. Call `list_accounts` (`workspace_id` optional). If none are connected, stop and send the user to connect social accounts in posterly. Do not invent account IDs.
3. Prefer `validate_post` before `create_post`. Show the preview. Wait for a clear yes.
4. Only then call `create_post` with `confirm: true`. Never publish or schedule live without that approval.
5. Prefer `scheduled_at` (ISO 8601 UTC) or `find_available_slot` (`account_ids`, `timezone`, `count`). Do not publish immediately unless the user asks.

## Rules

- posterly is the publish layer. This client is the chat or agent layer.
- Never collect card details, posterly passwords, or social-network passwords. Send the user to https://www.poster.ly/agents/signup or https://www.poster.ly/dashboard/api.
- Point to https://www.poster.ly/mcp for the rest of the 61 hosted HTTP MCP tools (64 on the local stdio package).
- After a post is created, send the View in posterly link. Avoid raw JSON dumps unless the user asks to debug.

## Media (honest)

Chat attachments never reach MCP. The paperclip in this chat does not give posterly the file.

The ~4MB limit is the **Vercel request body** on posterly API routes (`/api/mcp`, `POST /api/v1/media/upload`). It is not an MCP protocol cap and not the plan storage cap. Base64 inflates files, so hosted `upload_media` is small images only (relay cap 5MB decoded).

- Public HTTPS URL: `upload_media` with `url` (optional `filename`, `content_type`) or pass `media_url` / `media_urls` on `validate_post` / `create_post`. Server fetch: about 5MB relay, 60MB hard cap. Large R2/S3 URLs fail with `remote_media_too_large`.
- Hosted `upload_media`: required `filename` + `base64_data`. Optional `content_type`. Hits the 4MB Vercel body. JPEG, PNG, GIF, WebP, MP4, MOV, WebM. HEIC is unsupported.
- Laptop file in ChatGPT web, Claude.ai, or Gemini web: `create_media_drop` (optional `filename`, optional `max_files`, default 10). Send the user `drop_url` (`https://www.poster.ly/drop/<token>`). They open it with no dashboard login and drop the file. Then `list_media` (`drop_session_id`) and pass `public_url` to `validate_post` / `create_post`. This is not the chat paperclip.
- Larger files, when this client can HTTP PUT: `create_signed_upload` (`filename`, `content_type`, `size`), PUT the raw bytes to the returned `upload_url` (object storage, not a posterly API route) with the returned headers, then pass `public_url` to `create_post`. That PUT does not hit the 4MB body. Plan video caps: Starter 500MB, Pro 750MB, Power 1GB, Agency 4GB.
- Muse is an OpenAPI Custom Connector first, so there is no local `file_path`. Small images: public URL or base64 `upload_media`. Laptop video: `create_media_drop` then `list_media`. PUT after `create_signed_upload` only if this Muse runtime can PUT. Hosted MCP is optional and is not streamable HTTP.

## Starter tools

- `whoami` (none): Call first. Returns the authenticated user, API key scopes, and workspaces.
- `list_accounts` workspace_id?: Connected social accounts. Stop if this is empty and send the user to connect accounts in posterly.
- `validate_post` account_id or username+platform, caption, scheduled_at?, media_url?, media_urls?, post_type?, workspace_id?: Dry run. Does not create a post. Use this before showing a preview.
- `create_post` same as validate_post, plus confirm: true (required): Destructive write. Refuse unless the user clearly approved caption, account, media, and schedule.
- `upload_media` filename, base64_data (hosted), or url. content_type optional. Stdio also accepts file_path.: Hosted path is base64 with a decoded file of 5MB or less. With url, posterly fetches a public HTTPS URL into storage (localhost and private IPs are blocked). Chat paperclip files never arrive here.
- `create_signed_upload` filename, content_type, size: Bypasses the Vercel ~4MB API body. Returns upload_url (object storage) and public_url. PUT raw bytes to upload_url, then pass public_url to create_post. Use this when the client can PUT (Cursor, Claude Code, Codex).
- `create_media_drop` filename?, max_files?: Creates a no-login page at https://www.poster.ly/drop/<token>. Send drop_url to the user. ChatGPT web, Claude.ai, and Gemini web laptop files use this, then list_media. Not the chat paperclip.
- `list_media` limit?, drop_session_id?: Newest media assets. After create_media_drop, pass drop_session_id and use public_url on validate_post / create_post.
- `find_available_slot` account_ids?, timezone?, workspace_id?, count?: Always pass timezone explicitly (IANA, e.g. Europe/London). Respects a 1-hour gap.
- `generate_captions` platforms (required), brief?, tone?, count?, mode?, source_caption?: Returns caption options only. It does not schedule or publish.
- `list_posts` status?, platform?, account_id?, workspace_id?, limit?: Upcoming or recent posts. status is scheduled, published, failed, or draft.

## Example prompts

- Using posterly, call whoami, then list my connected accounts. Tell me which ones I can post to.
- Draft one caption for LinkedIn, X, and Instagram about our product launch. Show me the drafts and wait.
- Find the next free slot in Europe/London, then validate_post a text post. Do not create_post yet.
- I have a public image URL. Upload it, validate_post an Instagram image post for tomorrow 9:00 Europe/London, and wait for my yes.
- I have a video on my laptop. Call create_media_drop, send me the /drop/ link, wait, then list_media and validate_post. Do not use the chat attachment.
- After I approve the caption, account, media, and time, create_post with confirm true and send the View in posterly link.
- Do not publish live. Prefer a scheduled time unless I explicitly ask to post now.
- If this Muse connector requires streamable HTTP, stay on the OpenAPI contract and tell me. Do not pretend hosted MCP works.

## Links

- Human landing: https://www.poster.ly/muse
- MCP hub: https://www.poster.ly/mcp
- Muse guide: https://www.poster.ly/docs/integrations/muse
- AI agents: https://www.poster.ly/agents
- Agent signup: https://www.poster.ly/agents/signup