# Get account info, usage, and limits
Source: https://developers.juicer.io/api-reference/account/get-account-info-usage-and-limits
/openapi/v1.yaml get /account
# Get feed analytics and engagement stats
Source: https://developers.juicer.io/api-reference/analytics/get-feed-analytics-and-engagement-stats
/openapi/v1.yaml get /feeds/{feed_id}/analytics
Returns engagement metrics, source breakdown, and top posts for a feed
within a date range. Defaults to the last 30 days.
# Look up posts for a handle, hashtag, or other term
Source: https://developers.juicer.io/api-reference/data-api/look-up-posts-for-a-handle-hashtag-or-other-term
/openapi/v1.yaml get /data/posts
Returns recent posts for the given term across the requested platforms.
Availability and coverage vary by platform; results are returned on a
best-effort basis.
**Term type — explicit or auto-detected.** Pass `term_type` to choose how
the term is interpreted. If omitted, it is auto-detected:
- Terms starting with `#` → `hashtag` (e.g. `#travel`)
- Terms starting with `@` or with no prefix → `username` (e.g. `@nasa` or `nasa`)
Some platforms only accept term types that can't be auto-detected and so
**require** an explicit `term_type` — e.g. Reddit (`channel` for a
subreddit, `mentions` for a keyword search). See the `term_type` parameter
for the supported value per platform.
**Supported platforms and term types** (this endpoint serves only
connection-free lookups, a subset of `GET /platforms`):
| Platform | term_type values |
| --- | --- |
| Bluesky | `username`, `hashtag` |
| Twitter (X) | `username`, `hashtag`, `mentions` |
| YouTube | `username`, `channel`, `hashtag` |
| Vimeo | `username` |
| Facebook | `username`, `hashtag` |
| Instagram | `username`, `hashtag` |
| Tumblr | `username`, `hashtag` |
| Pinterest | `username`, `hashtag` |
| Flickr | `username` |
| Giphy | `username` |
| LinkedIn | `username`, `hashtag` |
| Reddit | `channel`, `mentions` |
| TikTok | `username`, `hashtag`, `mentions` |
| Google | `reviews` |
Google Reviews are fetched by Google Place ID (the `term`), not a handle,
and the Place ID can't be auto-detected — so Google **requires** an
explicit `term_type=reviews`. Resolve a business name to a Place ID first
via `GET /data/profiles` (a Google place search), then pass that Place ID
back here as the `term`.
A platform not listed here, or an unsupported `term_type` for a listed
platform, comes back in `meta.platforms` with an error — other platforms
in the same request still return.
**Pagination.** Each call returns one upstream page per platform (the page
size is whatever the platform's API returns — it varies by platform and is
not configurable; there is no `limit`/`per_page` param). Every successful
`meta.platforms[]` entry includes a `next_cursor` and `has_more`. To fetch
the next page, repeat the same request (same `term`/`platforms`/`term_type`)
and add the `cursor` param with the `next_cursor` value(s) you received.
Pagination is per-platform: in a multi-platform request, pass a
comma-separated list of the cursors for the platforms you want to continue;
platforms whose `next_cursor` was `null` have no more results. Cursors are
opaque — do not parse or construct them.
# Look up the canonical profile per platform for a handle
Source: https://developers.juicer.io/api-reference/data-api/look-up-the-canonical-profile-per-platform-for-a-handle
/openapi/v1.yaml get /data/profiles
Resolves one or more handles to their canonical profile on each
requested platform. Pass several handles as a comma-separated `term`
list — every term is looked up on every platform independently, and
each `data[]` entry is a `{ platform, term, exact_match, profiles[] }`
group. Hashtag terms (`#foo`) are rejected.
Every profile object includes every field and every `metrics` key;
any value not available for a given account is `null`. Do not assume a
field is always present — coverage varies by platform and account.
When a platform has an exact handle match, `profiles` holds that one
account (`exact_match: true`). Otherwise it holds best-effort candidate
matches for you to disambiguate (`exact_match: false`).
If one platform fails or has no result, others still return. Check
`meta.platforms` for per-platform status.
# Get embed code snippets
Source: https://developers.juicer.io/api-reference/embed/get-embed-code-snippets
/openapi/v1.yaml get /feeds/{feed_id}/embed
Returns ready-to-use embed snippets for displaying the feed on a website.
Includes JavaScript, iframe, WordPress shortcode, and WordPress PHP options.
# Create a new feed
Source: https://developers.juicer.io/api-reference/feeds/create-a-new-feed
/openapi/v1.yaml post /feeds
Creates a new feed. Returns `422` with `error.code = "feed_limit_reached"`
and an upgrade action if your plan's feed limit is exceeded.
# Delete a feed
Source: https://developers.juicer.io/api-reference/feeds/delete-a-feed
/openapi/v1.yaml delete /feeds/{id}
# Get feed details
Source: https://developers.juicer.io/api-reference/feeds/get-feed-details
/openapi/v1.yaml get /feeds/{id}
Returns feed details. Use `?include=sources` to embed sources in the response.
# List all feeds
Source: https://developers.juicer.io/api-reference/feeds/list-all-feeds
/openapi/v1.yaml get /feeds
# Update feed settings
Source: https://developers.juicer.io/api-reference/feeds/update-feed-settings
/openapi/v1.yaml patch /feeds/{id}
Updates feed settings, including manual and AI moderation.
**AI moderation** requires the Pro plan or higher. Enabling it
(`ai_moderation` or any AI sub-filter) on an unsupported plan returns
`422` with `error.code = "ai_moderation_not_available"` and an
`error.action` of type `upgrade_plan` containing a magic link to the
upgrade page.
# List available platforms and term types
Source: https://developers.juicer.io/api-reference/platforms/list-available-platforms-and-term-types
/openapi/v1.yaml get /platforms
Returns all social media platforms that Juicer supports, along with
the term types each platform accepts. Each term type includes its
OAuth connection requirements, so you know upfront whether the user
needs to connect an account before creating a source.
# Approve a moderated post
Source: https://developers.juicer.io/api-reference/posts/approve-a-moderated-post
/openapi/v1.yaml post /feeds/{feed_id}/posts/{id}/approve
Restores a moderated, deleted, or rejected post back to public.
# Bulk moderate posts
Source: https://developers.juicer.io/api-reference/posts/bulk-moderate-posts
/openapi/v1.yaml post /feeds/{feed_id}/posts/bulk
# Delete a post
Source: https://developers.juicer.io/api-reference/posts/delete-a-post
/openapi/v1.yaml delete /feeds/{feed_id}/posts/{id}
Soft-deletes the post. It can be recovered via the approve endpoint.
# Get a single post
Source: https://developers.juicer.io/api-reference/posts/get-a-single-post
/openapi/v1.yaml get /feeds/{feed_id}/posts/{id}
# List posts from a feed
Source: https://developers.juicer.io/api-reference/posts/list-posts-from-a-feed
/openapi/v1.yaml get /feeds/{feed_id}/posts
Returns paginated posts from a feed. Supports filtering by source, platform, date range, and text search.
# Pin a post to the top of the feed
Source: https://developers.juicer.io/api-reference/posts/pin-a-post-to-the-top-of-the-feed
/openapi/v1.yaml post /feeds/{feed_id}/posts/{id}/pin
# Reject a post
Source: https://developers.juicer.io/api-reference/posts/reject-a-post
/openapi/v1.yaml post /feeds/{feed_id}/posts/{id}/reject
# Unpin a post
Source: https://developers.juicer.io/api-reference/posts/unpin-a-post
/openapi/v1.yaml post /feeds/{feed_id}/posts/{id}/unpin
# API v1 endpoint index
Source: https://developers.juicer.io/api-reference/quickstart/api-v1-endpoint-index
/openapi/v1.yaml get /
Lists all v1 endpoints with a quickstart hint pointing at /v1/authorize. Intended for AI/CLI callers that haven't read this spec.
# Get an API key with an email (no dashboard, no prior signup)
Source: https://developers.juicer.io/api-reference/quickstart/get-an-api-key-with-an-email-no-dashboard-no-prior-signup
/openapi/v1.yaml post /authorize
Provision an API key using just an email address. The behavior depends
on whether the email already belongs to a confirmed Juicer account:
- **New or unconfirmed email** — returns a short-lived (2 hour)
temporary API key immediately (Mode A). Subject to a strict per-key
rate limit until the user confirms the email we send. Once
confirmed the same key is extended to the standard 12-hour
session TTL — it is not promoted to a permanent key.
- **Existing confirmed user** — returns a **device authorization**
request (Mode B) with an `authorization_url` the user must visit to
approve access. Poll `poll_url` until the key is issued. The
resulting key is also a 12-hour temporary key.
**Every key issued by this endpoint is time-bounded.** For a long-lived
key, users should generate one from the Developer page in the Juicer
dashboard; that is the only path to a permanent key. The dashboard key
and any number of `/authorize`-issued keys coexist — issuing a new
session key never revokes an existing permanent or session key.
# Poll the status of a device authorization request
Source: https://developers.juicer.io/api-reference/quickstart/poll-the-status-of-a-device-authorization-request
/openapi/v1.yaml get /authorize/{request_id}
Poll for the outcome of a Mode B authorization request. Returns:
- **202** — still pending (keep polling).
- **200** — approved; the body contains a 12-hour temporary `api_key`.
The key is returned **once**; subsequent polls return 410.
- **410** — denied, expired, or already delivered.
# Search posts across all feeds
Source: https://developers.juicer.io/api-reference/search/search-posts-across-all-feeds
/openapi/v1.yaml get /search/posts
Searches for posts matching a text query across all of the account's feeds.
Use `+` between terms for AND matching, or `,` for OR matching.
# Check connection status per platform
Source: https://developers.juicer.io/api-reference/social-accounts/check-connection-status-per-platform
/openapi/v1.yaml get /social_accounts/status
Returns which platforms that require OAuth are connected and which need
connecting. Use this before creating sources to know if the user needs
to authorize first.
# Disconnect a social account
Source: https://developers.juicer.io/api-reference/social-accounts/disconnect-a-social-account
/openapi/v1.yaml delete /social_accounts/{id}
# Generate OAuth connection link
Source: https://developers.juicer.io/api-reference/social-accounts/generate-oauth-connection-link
/openapi/v1.yaml post /social_accounts/connect_url
Generates a single-use magic link that signs the user in and redirects
straight to the OAuth authorization page. The user does **not** need to
be logged into Juicer — just clicking the link is enough.
The link expires in 30 minutes and can only be used once.
**Agent workflow:**
1. Call this endpoint with the provider
2. Present the `connection_url` to the user (e.g., "Click here to connect Instagram")
3. User clicks, authorizes, and is redirected back to Juicer
4. Poll `GET /social_accounts` or `GET /social_accounts/status` to confirm the connection
# List connected social accounts
Source: https://developers.juicer.io/api-reference/social-accounts/list-connected-social-accounts
/openapi/v1.yaml get /social_accounts
Returns all social accounts connected across the account
(including accounts connected by other team members).
Several platforms require a connected social account before you can
create sources for them; use `GET /platforms` or
`GET /social_accounts/status` to discover which apply to the caller.
# Add a source to a feed
Source: https://developers.juicer.io/api-reference/sources/add-a-source-to-a-feed
/openapi/v1.yaml post /feeds/{feed_id}/sources
Creates a new source and performs an initial sync to fetch posts.
Some platforms (like LinkedIn) sync asynchronously — check `syncable` status after creation.
Use `GET /platforms` to see available platforms and their supported term types.
**Example — Reddit:** use `term_type: "channel"` with a subreddit name
(or `reddit.com/r/...` URL) to pull a subreddit's posts, or
`term_type: "mentions"` with any keyword to pull Reddit search results:
```json
{ "platform": "Reddit", "term": "aww", "term_type": "channel" }
{ "platform": "Reddit", "term": "your brand", "term_type": "mentions" }
```
Returns `422` with `error.code = "source_limit_reached"` and an upgrade action
if the feed's source limit is exceeded. Returns `422` with
`error.code = "social_account_required"` and a connect action if the platform
requires OAuth and no account is connected.
# List sources for a feed
Source: https://developers.juicer.io/api-reference/sources/list-sources-for-a-feed
/openapi/v1.yaml get /feeds/{feed_id}/sources
# Remove a source from a feed
Source: https://developers.juicer.io/api-reference/sources/remove-a-source-from-a-feed
/openapi/v1.yaml delete /feeds/{feed_id}/sources/{id}
# Assign a feed to a user
Source: https://developers.juicer.io/api-reference/users/assign-a-feed-to-a-user
/openapi/v1.yaml put /users/{user_id}/feeds/{feed_id}
Creates an assignment linking the user to the given feed. The feed must
belong to the current account. Subject to the user's plan feed limit.
Idempotent — returns `200` when the assignment already exists.
# Create a sign-in token for a collaborator
Source: https://developers.juicer.io/api-reference/users/create-a-sign-in-token-for-a-collaborator
/openapi/v1.yaml post /users/{id}/sign_in_token
Mints a short-lived, single-use **sign-in token** for a **collaborator**
in the account, so you can drop that collaborator straight into their
Juicer dashboard without showing the login screen — for example, when
embedding the dashboard in an iframe on your own site.
The returned `sign_in_url` signs the user in and redirects to their
dashboard. It is built against your account's white-label host when one
is configured, so it works as an iframe `src` on your site. The token
expires in 30 minutes and can only be used once.
Pass an optional `feed_id` to land the user directly on that feed's
editor instead of the dashboard home — useful right after creating a
feed for the collaborator. The feed must be one the collaborator is
assigned to, otherwise the call returns `404`.
Requires an account owner or manager API key. The target user must be a
collaborator in the current account; minting a token for an owner or
manager returns `422`.
This endpoint is only available when sign-in tokens are enabled for your
account; otherwise it returns `403`.
**Token reuse is keyed on the destination.** If the collaborator already
has an unconsumed token for the same destination, you normally get that
same token back rather than a new one; concurrent calls for the same
destination may still mint separate tokens. The dashboard home and a
specific `feed_id` are different destinations, so a request for each one
returns a different token.
Expiry alone does not retire a token. A token that has expired but was
never opened is revived rather than replaced: the next call returns that
same token with a fresh 30-minute window. A token that is still valid is
returned unchanged, so its `expires_at` is the time left on the original
window rather than a fresh 30 minutes. A genuinely new token is minted
only once the previous one has been consumed.
Generate the token server-side at page-load time. Never persist it, share
it between users, or write it to logs. For its 30-minute window the URL
grants immediate access to the collaborator's dashboard.
# Fetch a single user
Source: https://developers.juicer.io/api-reference/users/fetch-a-single-user
/openapi/v1.yaml get /users/{id}
# Invite a manager or collaborator
Source: https://developers.juicer.io/api-reference/users/invite-a-manager-or-collaborator
/openapi/v1.yaml post /users
Invites a new user to the current account. Requires an API key belonging
to an account owner or manager.
**Managers** receive a Devise admin invitation. They may only be invited
if they are on the free plan with no feeds and no existing enterprise
account. `feed_ids` is ignored for managers — managers gain access to all
feeds on the account once they accept the invitation.
**Collaborators** can be invited with or without feeds. When `feed_ids`
is provided, each ID must belong to the current account and the collaborator
is assigned to those feeds (first feed triggers a "new feed" email for
existing users; new users receive a Devise invitation). When `feed_ids`
is omitted or empty, the collaborator is pre-provisioned with no
assignments — feeds can be attached later via
`PUT /v1/users/{user_id}/feeds/{feed_id}`.
Inviting users (either role) requires the **Enterprise** or **Team**
plan. Accounts on other plans receive `422` with
`error.code = "user_limit_reached"` and an `error.action` of type
`upgrade_plan` containing a magic link to the upgrade page.
# List account users
Source: https://developers.juicer.io/api-reference/users/list-account-users
/openapi/v1.yaml get /users
Returns managers and collaborators on the current account plus any users
with pending admin invitations. Requires an API key belonging to an
account owner or manager.
# Remove a feed assignment from a user
Source: https://developers.juicer.io/api-reference/users/remove-a-feed-assignment-from-a-user
/openapi/v1.yaml delete /users/{user_id}/feeds/{feed_id}
Removes the assignment linking the user to the feed. If this would
leave an enterprise/team user with zero feeds, the call fails with
`422 last_feed_removal_blocked` — delete the user instead. If the feed
has no remaining assignments after removal, the feed is soft-deleted.
# Remove a user from the account
Source: https://developers.juicer.io/api-reference/users/remove-a-user-from-the-account
/openapi/v1.yaml delete /users/{id}
Removes the user from this account. If the user has a pending admin
invitation, the invitation is cleared. Otherwise the user is downgraded
to a personal free plan and all of their assignments are removed.
The account owner cannot be deleted, and a caller cannot delete themselves.
# A connected social accounts token expires within five days
Source: https://developers.juicer.io/api-reference/webhooks/a-connected-social-accounts-token-expires-within-five-days
/openapi/v1.yaml webhook socialAccountExpiring
# A connected social accounts token has expired
Source: https://developers.juicer.io/api-reference/webhooks/a-connected-social-accounts-token-has-expired
/openapi/v1.yaml webhook socialAccountExpired
# Create a webhook subscription
Source: https://developers.juicer.io/api-reference/webhooks/create-a-webhook-subscription
/openapi/v1.yaml post /webhooks
The `secret` is returned only in the creation response. Store it securely —
it's used to verify webhook payloads via HMAC-SHA256 signature in the
`X-Juicer-Signature` header.
See the `WebhookDeliveryBody` schema for the shape your endpoint will
receive, how to verify the signature, and how to dedup retries.
# Delete a webhook
Source: https://developers.juicer.io/api-reference/webhooks/delete-a-webhook
/openapi/v1.yaml delete /webhooks/{id}
# Get event details with delivery history
Source: https://developers.juicer.io/api-reference/webhooks/get-event-details-with-delivery-history
/openapi/v1.yaml get /webhook_events/{id}
# List deliveries for a webhook
Source: https://developers.juicer.io/api-reference/webhooks/list-deliveries-for-a-webhook
/openapi/v1.yaml get /webhooks/{webhook_id}/deliveries
# List webhook events
Source: https://developers.juicer.io/api-reference/webhooks/list-webhook-events
/openapi/v1.yaml get /webhook_events
# List webhook subscriptions
Source: https://developers.juicer.io/api-reference/webhooks/list-webhook-subscriptions
/openapi/v1.yaml get /webhooks
# New posts were ingested by a sync
Source: https://developers.juicer.io/api-reference/webhooks/new-posts-were-ingested-by-a-sync
/openapi/v1.yaml webhook postCreated
# Replay a failed delivery
Source: https://developers.juicer.io/api-reference/webhooks/replay-a-failed-delivery
/openapi/v1.yaml post /webhooks/{webhook_id}/deliveries/{id}/redeliver
Queues a fresh delivery of the same event to the same endpoint, with its
own full run of automatic retries — use it once a delivery has exhausted
the retries Juicer makes on its own. The replay is a new delivery row
starting at `attempt_number` 1; the event `id` your endpoint receives is
unchanged, so a receiver that already processed it dedups as usual.
A `disabled` webhook accepts the request but never sends the delivery.
# Send a test event to the webhook
Source: https://developers.juicer.io/api-reference/webhooks/send-a-test-event-to-the-webhook
/openapi/v1.yaml post /webhooks/{id}/test
# Update a webhook
Source: https://developers.juicer.io/api-reference/webhooks/update-a-webhook
/openapi/v1.yaml patch /webhooks/{id}
# Authentication
Source: https://developers.juicer.io/authentication
Use a Bearer API key to authenticate every request.
All requests require an API key passed as a Bearer token:
```bash theme={null}
Authorization: Bearer jcr_your_api_key_here
```
## Getting an API key
You can obtain a key two ways:
### 1. From the dashboard (permanent key)
Sign in at [juicer.io](https://www.juicer.io/feeds) and create a key on the **Developer** page. Dashboard-issued keys never expire and are the right choice for long-running production integrations.
### 2. Programmatically via `POST /v1/authorize` (temporary key)
For CLI tools, AI agents, and one-off scripts, you can request a key with just an email address — no dashboard or prior signup needed.
```bash theme={null}
curl -X POST https://api.juicer.io/v1/authorize \
-H "Content-Type: application/json" \
-d '{"email": "you@example.com", "client_name": "My Tool"}'
```
There are two outcomes:
* **New email** — returns an `api_key` immediately. Valid for 2 hours pre-confirmation, extended to 12 hours once the user confirms the email.
* **Existing confirmed user** — returns an `authorization_url` (the user opens it in a browser to approve the request) plus a `poll_url` you GET until the key is issued.
Every key issued through `/authorize` is time-bounded. For a permanent key, generate one from the dashboard.
Issuing a new session key never revokes existing keys. Permanent and session
keys coexist on the same account.
## Key format
API keys are prefixed with `jcr_`. Treat them as secrets — never embed them in client-side code.
## Rate limits
Rate limits depend on whether the key is pre-confirmation, confirmed-session, or permanent. Pre-confirmation keys are limited to 60 requests/hour; confirmed and permanent keys to 300 requests/hour with a 60/minute burst by default. Higher limits are available on paid plans.
When you exceed the limit, the API returns `429 Too Many Requests`.
# Juicer Developer Docs - One API for Every Social Platform
Source: https://developers.juicer.io/introduction
One unified API for Instagram, TikTok, YouTube, X, and 15+ social platforms. Read feeds, sources, and posts without integrating each platform individually.
The Juicer API gives you two products under one API key:
* **Integration API** — Programmatically manage feeds, sources, posts, moderation, analytics, and webhooks.
* **Data API** — Query social media posts directly without setting up a feed.
## Base URL
```text theme={null}
https://api.juicer.io/v1
```
## Where to next
Learn how API keys work and how to obtain one without the dashboard.
Create a feed, add a source, and get an embed snippet in five calls.
Full reference for every endpoint.
Connect Claude, Cursor, and ChatGPT to Juicer in natural language.
Manage feeds, sources, and billing in the Juicer dashboard.
# Connect & Setup
Source: https://developers.juicer.io/mcp-connect
Connect any MCP client to the Juicer MCP Server — endpoint, authentication, and per-client setup for Claude, Cursor, VS Code, and more.
Connect any MCP client to Juicer with **just the server URL**. Most clients handle authorization for you through a browser sign-in; if yours doesn't, pass an API key as a bearer token instead.
## Endpoint and transport
```text theme={null}
Endpoint: https://api.juicer.io/mcp
Transport: Streamable HTTP (stateless)
```
## Authentication
The server accepts two ways to authenticate. Pick whichever your client supports.
### OAuth 2.1 (recommended)
Connect with only the URL. The first time your client reaches the server it opens a browser, you sign in to Juicer and click **Authorize**, and the client receives a token automatically — there's nothing to copy or paste.
Behind the scenes, approving creates a named API key scoped to your account. You can review or revoke it anytime from the [API dashboard](https://www.juicer.io/dashboard-api).
Authorizing grants a client access to your feeds and team. Only authorize
clients you trust, and revoke any you no longer use from the
[API dashboard](https://www.juicer.io/dashboard-api).
### API key (bearer token)
If your client doesn't support OAuth, or you're scripting against the server, pass a `jcr_` API key directly as a bearer token and skip the browser flow:
```text theme={null}
Authorization: Bearer jcr_your_api_key_here
```
Generate a key from the [API dashboard](https://www.juicer.io/dashboard-api) or the device-authorization flow (see [Authentication](/authentication)). Treat it like a password — never commit it to source control.
## Connect
```bash theme={null}
claude mcp add --transport http juicer https://api.juicer.io/mcp
```
The first call opens your browser to authorize. Approve, and you're connected.
To skip OAuth and use an API key:
```bash theme={null}
claude mcp add --transport http juicer https://api.juicer.io/mcp \
--header "Authorization: Bearer jcr_your_api_key_here"
```
Open **Settings → Connectors → Add custom connector**, then enter:
* **Name:** `Juicer`
* **URL:** `https://api.juicer.io/mcp`
Save, then click **Connect** — a browser opens for you to sign in and authorize.
Open the command palette (`Cmd/Ctrl+Shift+P`) → **Open MCP settings**, and add to `mcp.json`:
```json theme={null}
{
"mcpServers": {
"Juicer": {
"url": "https://api.juicer.io/mcp"
}
}
}
```
Cursor opens a browser to authorize the first time the server is used.
Create `.vscode/mcp.json`:
```json theme={null}
{
"servers": {
"juicer": {
"type": "http",
"url": "https://api.juicer.io/mcp"
}
}
}
```
Restart your MCP client after adding the server or changing your key so the
new configuration takes effect.
## Next steps
The 33 tools you can now call, grouped by domain.
How the server works and how it relates to the REST API.
# Documentation MCP
Source: https://developers.juicer.io/mcp-docs-search
Connect the read-only Juicer Documentation MCP server to your AI agent to search the Juicer API docs in natural language.
The **Documentation MCP** server lets an AI agent search and read the Juicer API documentation over [Model Context Protocol](https://modelcontextprotocol.io). Point your agent at it and it can answer questions from these docs, find the right endpoint, and generate correct code — without you copy-pasting pages into the chat.
This server is **read-only** and scoped to the documentation. To let an agent
actually operate on your account — create feeds, moderate posts, pull
analytics — use the [MCP Server](/mcp-server) instead.
With the Documentation MCP connected, an agent can:
* Search the Juicer API docs and guides for relevant content.
* Read any documentation page or the OpenAPI spec in full.
* Generate accurate, up-to-date code against the current API.
* Ground its answers in the published docs instead of stale prior knowledge.
## Server URL
```text theme={null}
https://developers.juicer.io/mcp
```
No authentication is required — it only exposes public documentation.
## Setup
```bash theme={null}
claude mcp add --transport http juicer-docs https://developers.juicer.io/mcp
```
Open **Settings → Connectors → Add custom connector**, then enter:
* **Name:** `Juicer Docs`
* **URL:** `https://developers.juicer.io/mcp`
Save, then click **Connect**.
Open the command palette (`Cmd/Ctrl+Shift+P`) → **Open MCP settings**, and add to `mcp.json`:
```json theme={null}
{
"mcpServers": {
"Juicer Docs": {
"url": "https://developers.juicer.io/mcp"
}
}
}
```
Create `.vscode/mcp.json`:
```json theme={null}
{
"servers": {
"juicer-docs": {
"type": "http",
"url": "https://developers.juicer.io/mcp"
}
}
}
```
Restart your MCP client after adding the server so the new configuration takes
effect.
## Try it
Once connected, ask your agent a question about the API and tell it to use the server:
> *"How do I create a feed and add an Instagram source with the Juicer API? Use the Juicer docs MCP server."*
The agent searches the docs, reads the relevant pages, and answers with references back to this site.
## Next steps
The action server that drives your account — feeds, posts, analytics, and more.
The full REST reference the docs are built on.
# MCP Server
Source: https://developers.juicer.io/mcp-server
Let AI agents drive the Juicer API over the Model Context Protocol (MCP). Manage feeds, sources, posts, and analytics in natural language.
The Juicer **MCP Server** lets AI agents drive the Juicer API through [Model Context Protocol](https://modelcontextprotocol.io) tools. Instead of writing REST calls by hand, an agent — Claude, Cursor, Windsurf, ChatGPT, or any MCP-capable client — connects to the server and calls Juicer tools to create feeds, add sources, moderate posts, pull analytics, manage the team, and look up social data.
Looking to let an agent **search these docs** instead of driving your account?
See the [Documentation MCP](/mcp-docs-search) — a separate, read-only server
for questions about the Juicer API. This page documents the **action** MCP
Server that operates on your feeds and data.
## How it works
Each MCP tool call is dispatched through the same API chain that powers the [REST API](/api-reference):
* Authentication of your API key
* Rate limiting for your plan tier
* Quota and usage enforcement
* The same controllers, validation, and serializers as the REST endpoints
The MCP Server holds no state of its own. It forwards every tool call to `https://api.juicer.io/v1` with your token and returns the API's response — including its structured error messages and upgrade hints — straight back to the agent. The result: **the MCP Server returns the same data and enforces the same rules as the REST API.**
## Who it's for
* **Agent builders** wiring an LLM up to Juicer to automate feed and content workflows.
* **Claude Code and Cursor users** who want to create feeds, add sources, and moderate posts from their editor.
* **Integrators** onboarding and managing feeds on behalf of many clients from a single account.
Every action runs as your Juicer account, with your exact plan limits and
permissions. Team management tools (inviting users, assigning feeds) require
an Enterprise or Team plan and an owner or manager API key.
## Endpoint and transport
```text theme={null}
Endpoint: https://api.juicer.io/mcp
Transport: Streamable HTTP (stateless)
Auth: OAuth 2.1 browser sign-in, or a jcr_ API key as a bearer token
```
## Relationship to the REST API
The MCP Server is a thin, hosted wrapper over the public API — not a separate product.
* The [**REST API**](/api-reference) is the underlying interface. Every endpoint is documented in the API Reference.
* The **MCP Server** exposes those same operations as tools an agent can call. Each tool maps to exactly one endpoint.
Anything you can do over MCP, you can do over REST, and vice versa. Reach for MCP when an agent should decide *which* calls to make; reach for REST when you're writing the integration yourself.
## Next steps
Add the server to Claude, Cursor, VS Code, and more — with OAuth or an API key.
The 33 tools the server exposes, grouped by domain with scope and purpose.
A read-only server that lets agents search these docs in natural language.
The REST endpoints every MCP tool maps to.
# Tool Catalog
Source: https://developers.juicer.io/mcp-tools
The 33 tools exposed by the Juicer MCP Server — account, feeds, sources, posts, moderation, social accounts, analytics, webhooks, team, and social data — grouped by domain.
The Juicer MCP Server exposes **33 tools**, one per public API operation. Every tool runs as your account and respects your plan's limits and permissions. This catalog is grouped by domain; each tool maps to an endpoint in the [API Reference](/api-reference).
## Conventions
* **Destructive tools ask for confirmation.** Tools that delete or hard-delete data are marked destructive in their description, and well-behaved clients confirm with you before running them. Review the action before approving.
* **Team tools need elevated access.** Inviting or removing users and assigning feeds require an owner or manager API key, and an Enterprise or Team plan.
* **Upgrade hints pass through.** When an action exceeds your plan (feed limits, team management), the tool returns a `422` with an actionable upgrade hint that the agent can surface to you.
This catalog reflects the live server's inventory. For the authoritative,
always-current list, an agent can call the MCP `tools/list` method.
## Account
| Tool | Purpose |
| ---------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `get_account` | Get the current account's plan, usage, limits, and enabled features. |
| `list_platforms` | List every supported platform and the term types it accepts (username, hashtag, page URL); call before `create_source`. |
## Feeds
| Tool | Purpose |
| ---------------- | ----------------------------------------------------------------------------------------------- |
| `list_feeds` | List all feeds on the account, paginated. Use it to find a feed's id. |
| `get_feed` | Get a single feed's details and moderation settings; pass `include="sources"` to embed sources. |
| `create_feed` | Create a new, empty feed. Returns its id and slug. |
| `update_feed` | Update a feed's name and/or moderation settings. |
| `delete_feed` | Permanently delete a feed and stop serving its embed. **Destructive.** |
| `get_feed_embed` | Get the embed snippets (JavaScript, iframe, WordPress shortcode) to place the feed on a site. |
## Sources
| Tool | Purpose |
| --------------- | ------------------------------------------------------------------------------------------------------------ |
| `list_sources` | List the sources feeding a given feed, with each one's sync status. Paginated. |
| `create_source` | Add a source to a feed (Instagram username, Twitter hashtag, Facebook page, …). Call `list_platforms` first. |
| `delete_source` | Remove a source from a feed. Posts already pulled remain unless separately deleted. |
## Posts & moderation
| Tool | Purpose |
| --------------------- | ------------------------------------------------------------------------------------------------- |
| `list_feed_posts` | List posts in a feed, paginated; filter by moderation `status`. |
| `get_feed_post` | Get a single post by id — media, engagement counts, poster, moderation status. |
| `moderate_post` | Moderate one post: `approve`, `reject`, `pin`, `unpin`, or `delete`. `delete` is **destructive**. |
| `bulk_moderate_posts` | Moderate many posts at once by `post_ids` or by `tab`. `hard_delete` is irreversible. |
## Social accounts
| Tool | Purpose |
| ----------------------------------- | ----------------------------------------------------------------------------------------------- |
| `list_social_accounts` | List OAuth-connected social accounts, including whether each has expired. Paginated. |
| `get_social_account_status` | Check per-platform connection status: connected, expired, or available to connect. |
| `create_social_account_connect_url` | Generate a single-use magic link to connect a social account via OAuth (expires in 30 minutes). |
| `delete_social_account` | Disconnect a social account. Dependent sources stop syncing. **Confirm first.** |
## Analytics
| Tool | Purpose |
| -------------------- | ---------------------------------------------------------------------------------------------------------- |
| `get_feed_analytics` | Engagement stats, source breakdown, and top posts for a feed over a date range (defaults to last 30 days). |
## Search & social data
| Tool | Purpose |
| ------------------- | ------------------------------------------------------------------------------------ |
| `search_posts` | Full-text search across posts already collected into the account's feeds. |
| `get_data_posts` | Data API: look up recent posts for a handle or hashtag across one or more platforms. |
| `get_data_profiles` | Data API: resolve one or more handles to their canonical profile on a platform. |
## Webhooks
| Tool | Purpose |
| ---------------- | -------------------------------------------------------------------------------------- |
| `list_webhooks` | List the account's webhook subscriptions with status and failure counts. Paginated. |
| `create_webhook` | Subscribe an HTTPS endpoint to Juicer events. Returns a signing `secret` (shown once). |
| `update_webhook` | Update a webhook's endpoint or subscribed events. |
| `delete_webhook` | Delete a webhook subscription; delivery stops immediately. |
| `test_webhook` | Send a test event so the user can verify their receiver and signature validation. |
## Team
Requires an owner or manager API key on an Enterprise or Team plan.
| Tool | Purpose |
| -------------------- | --------------------------------------------------------------------------------- |
| `list_users` | List the account's users with roles and feed assignments. Paginated. |
| `create_user` | Invite a user as a `manager` (all feeds) or `collaborator` (assigned feeds only). |
| `delete_user` | Remove a user from the account, revoking access. **Confirm first.** |
| `assign_user_feed` | Assign a feed to a user so they can access it. Idempotent. |
| `unassign_user_feed` | Remove a user's assignment to a feed, revoking access to it. |
## Example prompts
Once connected, just ask:
* *"Create a feed called Summer Campaign and add the Instagram account @nasa to it."*
* *"Show me the most engaged posts in my Brand feed over the last 7 days."*
* *"Anything in the moderation queue for feed 1240? Approve the ones from verified accounts."*
* *"Give me the embed code for my Events feed for WordPress."*
* *"Look up the TikTok and YouTube profiles for the handle 'juicer'."*
# Quickstart
Source: https://developers.juicer.io/quickstart
Connect Instagram, TikTok, YouTube, X, and 15+ social platforms with Juicer's API. Create a feed, add a source, and ship an embeddable snippet in five API calls.
This walkthrough takes you from zero to an embeddable feed.
## 0. Get an API key
If you don't have one yet, request a temporary key:
```bash theme={null}
curl -X POST https://api.juicer.io/v1/authorize \
-H "Content-Type: application/json" \
-d '{"email": "you@example.com", "client_name": "My Tool"}'
```
See [Authentication](/authentication) for how the response is shaped.
## 1. Check your account
```bash theme={null}
curl https://api.juicer.io/v1/account \
-H "Authorization: Bearer jcr_your_key"
```
Returns your plan, current usage, and feature flags.
## 2. See available platforms
```bash theme={null}
curl https://api.juicer.io/v1/platforms \
-H "Authorization: Bearer jcr_your_key"
```
Each platform lists its supported `term_type` values and whether OAuth is required before you can create sources for it.
## 3. Create a feed
```bash theme={null}
curl -X POST https://api.juicer.io/v1/feeds \
-H "Authorization: Bearer jcr_your_key" \
-H "Content-Type: application/json" \
-d '{"name": "My Brand Feed"}'
```
## 4. Add a source
```bash theme={null}
curl -X POST https://api.juicer.io/v1/feeds/{feed_id}/sources \
-H "Authorization: Bearer jcr_your_key" \
-H "Content-Type: application/json" \
-d '{"platform": "YouTube", "term": "NASA", "term_type": "username"}'
```
Some platforms require a connected social account before sources can be created. Whether a given term type needs one is account-aware, so always check at runtime via `GET /platforms` (look at `requires_connection` on each term type) or `GET /social_accounts/status`. See [Connecting Social Accounts](#connecting-social-accounts) below for the flow.
## 5. Get the embed code
```bash theme={null}
curl https://api.juicer.io/v1/feeds/{feed_id}/embed \
-H "Authorization: Bearer jcr_your_key"
```
Returns four ready-to-use snippets:
* **JavaScript** — `