Connect

8 clients · secrets stay placeholders

JSON (mcpServers)Claude CodeCodexOpenCodeCursorVS CodeGemini CLIGoose

{
  "mcpServers": {
    "slopit": {
      "type": "http",
      "url": "https://slopit.io/mcp",
      "headers": {
        "Authorization": "Bearer ${SLOPIT_TOKEN}"
      }
    }
  }
}

claude mcp add --transport http slopit https://slopit.io/mcp --header "Authorization: Bearer ${SLOPIT_TOKEN}"

[mcp_servers.slopit]
url = "https://slopit.io/mcp"
bearer_token_env_var = "SLOPIT_TOKEN"

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "slopit": {
      "type": "remote",
      "url": "https://slopit.io/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer {env:SLOPIT_TOKEN}"
      }
    }
  }
}

{
  "mcpServers": {
    "slopit": {
      "type": "http",
      "url": "https://slopit.io/mcp",
      "headers": {
        "Authorization": "Bearer ${SLOPIT_TOKEN}"
      }
    }
  },
  "deeplink": "cursor://anysphere.cursor-deeplink/mcp/install?name=slopit&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8vc2xvcGl0LmlvL21jcCIsImhlYWRlcnMiOnsiQXV0aG9yaXphdGlvbiI6IkJlYXJlciAke1NMT1BJVF9UT0tFTn0ifX0%3D"
}

{
  "servers": {
    "slopit": {
      "type": "http",
      "url": "https://slopit.io/mcp",
      "headers": {
        "Authorization": "Bearer ${SLOPIT_TOKEN}"
      }
    }
  }
}

{
  "mcpServers": {
    "slopit": {
      "httpUrl": "https://slopit.io/mcp",
      "headers": {
        "Authorization": "Bearer ${SLOPIT_TOKEN}"
      }
    }
  }
}

extensions:
  "slopit":
    enabled: true
    name: "slopit"
    type: streamable_http
    uri: "https://slopit.io/mcp"
    headers:
      "Authorization": "Bearer ${SLOPIT_TOKEN}"
    timeout: 300

Placeholders to fill from your own secret store: ${SLOPIT_TOKEN}. The registry never accepts secret values.

Quality 72 / 100needs work

protocol75 · weight 25

warn
protocol.modernnewest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
n/a
protocol.statelessonly applies to 2026-07-28 servers
pass
protocol.transportstreamable HTTP
n/a
protocol.list_ttlonly applies to 2026-07-28 servers

authorizationn/a · weight 15

n/a
auth.prm, auth.as_metadata, auth.cimdno remote uses OAuth
n/a
auth.secret_in_urlno templated URL

tool hygiene93 · weight 30

pass
tools.descriptionsevery tool has a description
warn
tools.description_length1 tools have descriptions over 1,024 characters, which crowds the context
pass
tools.schemasevery tool has an object input schema
pass
tools.annotations13 of 13 tools declare readOnlyHint or destructiveHint
pass
tools.directory_hintsevery tool declares readOnlyHint, destructiveHint, idempotentHint and openWorldHint
pass
tools.token_costabout 5,412 tokens to load every tool
pass
tools.api_dumptools are not a one-to-one API dump

stability25 · weight 15

warn
stability.changes26 tool changes in 30 days
fail
stability.rug_pull5 tools kept their name but changed most of their description in 30 days; review before trusting them

dependenciesn/a · weight 15

n/a
deps.known_vulns, deps.mcp_sdk_version, deps.resolvableno npm or PyPI package

13 tools, about 5,412 tokens to load them all · tool set a091d350fe4a · tools last changed 2026-10-15 · checked 2026-10-20 15:57 UTC

Tool changes

2026-10-15get_postchangeddescription, output schemameaning changed
before
Get a single post by its slug.
after · 27% of words in common
Get a single post by its slug. A draft also comes with `preview_url`, a private link to show the human how it looks, when the host has previews.
2026-10-15get_blogchangeddescription, output schemameaning changed
before
Get the blog's current metadata.
after · 27% of words in common
Get the blog's current metadata and its public URL, `blog_url`. A post's page is {blog_url}{slug}/; use it to link posts to each other.
2026-10-15update_blogchangedoutput schema
2026-10-15update_postchangeddescription, input schema, output schema
before
Edit an existing post. Pass the post's `slug` and a `patch` of fields to change; `coverImage: null` removes the cover. Use this when the user wants a published post or draft changed. `patch: { status: "draft" }` takes a live post offline and `"published"` puts a draft live. Slug itself can't change; delete and republish if you need a new URL. Afterwards, give the user the returned `post_url` when the post is published. On POST_NOT_FOUND, find the right slug with list_posts (pass `status: "draft"` for drafts).
after · 98% of words in common
Edit an existing post. Pass the post's `slug` and a `patch` of fields to change; `coverImage: null` removes the cover. Use this when the user wants a published post or draft changed. `patch: { status: "draft" }` takes a live post offline and `"published"` puts a draft live. Slug itself can't change; delete and republish if you need a new URL. Afterwards, give the user the returned `post_url` when the post is published, or the `preview_url` of a draft. On POST_NOT_FOUND, find the right slug with list_posts (pass `status: "draft"` for drafts).
2026-10-15create_postchangeddescription, input schema, output schema
before
Publish a post to the blog. Needs `title` and `body` (markdown). Returns the published post's live URL. Use this when the user asks you to write and publish a blog post, article, changelog, announcement or update they want to share as a link. `status: "draft"` saves it without publishing. To publish a translation of an existing post, pass `translationOf: <its slug>` and the translation's `language`. Afterwards, always give the user the returned `post_url` (drafts have none). On UNAUTHORIZED, you have no valid API key: call `signup` first, or ask the human for their key. On POST_SLUG_CONFLICT, pick another `slug`, or use update_post to change the existing post; on a retry it usually means the first call worked, so check with get_post. Pass an `idempotency_key` to make retries safe.
after · 88% of words in common
Publish a post to the blog. Needs `title` and `body` (markdown). Returns the published post's live URL. Use this when the user asks you to write and publish a blog post, article, changelog, announcement or update they want to share as a link. `status: "draft"` saves it without publishing. To publish a translation of an existing post, pass `translationOf: <its slug>` and the translation's `language`. Afterwards, always give the user the returned `post_url`. A draft has none: give its `preview_url` instead, when there is one, so the human can see it before it goes live. On UNAUTHORIZED, you have no valid API key: call `signup` first, or ask the human for their key. On POST_SLUG_CONFLICT, pick another `slug`, or use update_post to change the existing post; on a retry it usually means the first call worked, so check with get_post. Pass an `idempotency_key` to make retries safe.
2026-10-11get_ai_readershipchangeddescription, output schema
before
How AI systems read this blog: reads by signal type over the last 7 days (Pro: 30 or 90), next to the equal period before. Use it when the user asks how the blog is doing with AI, whether ChatGPT, Claude or Perplexity read it, which posts AI reads, or who reads the blog (AI systems only; human visitors are not counted here). Four tiers, strongest signal first. `click`: a reader followed a link to the blog from an AI assistant's answer. `live`: an AI fetched a page while answering someone; it does not mean the answer showed or cited it. `search`: an AI search crawler read the page, so it can show up in AI search answers. `training`: an AI company's crawler copied the page; it may be used to train future models. Report a `live` read as "fetched live by ChatGPT while answering someone", never as cited, mentioned, ranked or recommended: we cannot see that. Say once that the numbers undercount: AI tools that answer from a saved copy do not ask the blog again (`notes` has the wording). `unverified` counts requests that claimed to be an AI crawler but failed the address check; they are not AI reads. Free blogs get the weekly `tiers`. Pro adds `posts` (per post), `systems` (per AI system, with counts) and 30 or 90 days; a free blog asking for more than 7 gets 7 and `locked`. When `upgrade` is present it says how to get Pro: mention it only if the human wants that detail. Counting began on `counting_since`: a short history means counting just started, not that nobody reads the blog.
after · 98% of words in common
How AI systems read this blog: reads by signal type over the last 7 days (Pro: 30 or 90), next to the equal period before. Use it when the user asks how the blog is doing with AI, whether ChatGPT, Claude or Perplexity read it, which posts AI reads, or who reads the blog (AI systems only; human visitors are not counted here). Four tiers, strongest signal first. `click`: a reader followed a link to the blog from an AI assistant's answer. `live`: an AI fetched a page while answering someone; it does not mean the answer showed or cited it. `search`: an AI search crawler read the page, so it can show up in AI search answers. `training`: an AI company's crawler copied the page; it may be used to train future models. Report a `live` read as "fetched live by ChatGPT while answering someone", never as cited, mentioned, ranked or recommended: we cannot see that. Say once that the numbers undercount: AI tools that answer from a saved copy do not ask the blog again (`notes` has the wording). `unverified` counts requests that claimed to be an AI crawler but failed the address check; they are not AI reads. Free blogs get the weekly `tiers`, each with the `names` of the AI systems in it. Pro adds `posts` (per post), `systems` (per AI system, with counts) and 30 or 90 days; a free blog asking for more than 7 gets 7 and `locked`. When `upgrade` is present it says how to get Pro: mention it only if the human wants that detail. Counting began on `counting_since`: a short history means counting just started, not that nobody reads the blog.
2026-10-11get_ai_readershipadded
How AI systems read this blog: reads by signal type over the last 7 days (Pro: 30 or 90), next to the equal period before. Use it when the user asks how the blog is doing with AI, whether ChatGPT, Claude or Perplexity read it, which posts AI reads, or who reads the blog (AI systems only; human visitors are not counted here). Four tiers, strongest signal first. `click`: a reader followed a link to the blog from an AI assistant's answer. `live`: an AI fetched a page while answering someone; it does not mean the answer showed or cited it. `search`: an AI search crawler read the page, so it can show up in AI search answers. `training`: an AI company's crawler copied the page; it may be used to train future models. Report a `live` read as "fetched live by ChatGPT while answering someone", never as cited, mentioned, ranked or recommended: we cannot see that. Say once that the numbers undercount: AI tools that answer from a saved copy do not ask the blog again (`notes` has the wording). `unverified` counts requests that claimed to be an AI crawler but failed the address check; they are not AI reads. Free blogs get the weekly `tiers`. Pro adds `posts` (per post), `systems` (per AI system, with counts) and 30 or 90 days; a free blog asking for more than 7 gets 7 and `locked`. When `upgrade` is present it says how to get Pro: mention it only if the human wants that detail. Counting began on `counting_since`: a short history means counting just started, not that nobody reads the blog.
2026-10-11delete_mediachangedannotations
2026-10-11upload_mediachangedannotations
2026-10-11update_blogchangedannotations

Showing the latest 10. Full history: list_changes · trend: quality JSON.

Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed. How it is computed.

Trust 96 / 100

provenance85

liveness100

freshness100

hygiene100

+repository +dns-namespace +website +reachable +uptime-100% +updated-5d-ago

Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed. How it is computed.

Endpoints

remote	auth	reachable	uptime 30d	p50	protocol	last ok
`https://slopit.io/mcp` streamable-http	none	yes	100%	551 ms	2025-11-25	2026-10-20

Tools (13)

`create_post`destructive	Publish a post to the blog. Needs `title` and `body` (markdown). Returns the published post's live URL. Use this when the user asks you to write and publish a blog post, article, changelog, announcement or update they want to share as a link. `status: "draft"` saves it without publishing. To publish a translation of an existing post, pass `translationOf: <its slug>` and the translation's `language`. Afterwards, always give the user the returned `post_url`. A draft has none: give its `preview_url` instead, when there is one, so the human can see it before it goes live. On UNAUTHORIZED, you have no valid API key: call `signup` first, or ask the human for their key. On POST_SLUG_CONFLICT, pick another `slug`, or use update_post to change the existing post; on a retry it usually means the first call worked, so check with get_post. Pass an `idempotency_key` to make retries safe.
`delete_media`destructive	Permanently delete an uploaded image by id. The URL stops working immediately. Posts that referenced it will show a broken image until edited.
`delete_post`destructive	Remove a post permanently. This can't be undone.
`get_ai_readership`read-only	How AI systems read this blog: reads by signal type over the last 7 days (Pro: 30 or 90), next to the equal period before. Use it when the user asks how the blog is doing with AI, whether ChatGPT, Claude or Perplexity read it, which posts AI reads, or who reads the blog (AI systems only; human visitors are not counted here). Four tiers, strongest signal first. `click`: a reader followed a link to the blog from an AI assistant's answer. `live`: an AI fetched a page while answering someone; it does not mean the answer showed or cited it. `search`: an AI search crawler read the page, so it can show up in AI search answers. `training`: an AI company's crawler copied the page; it may be used to train future models. Report a `live` read as "fetched live by ChatGPT while answering someone", never as cited, mentioned, ranked or recommended: we cannot see that. Say once that the numbers undercount: AI tools that answer from a saved copy do not ask the blog again (`notes` has the wording). `unverified` counts requests that claimed to be an AI crawler but failed the address check; they are not AI reads. Free blogs get the weekly `tiers`, each with the `names` of the AI systems in it. Pro adds `posts` (per post), `systems` (per AI system, with counts) and 30 or 90 days; a free blog asking for more than 7 gets 7 and `locked`. When `upgrade` is present it says how to get Pro: mention it only if the human wants that detail. Counting began on `counting_since`: a short history means counting just started, not that nobody reads the blog.
`get_blog`read-only	Get the blog's current metadata and its public URL, `blog_url`. A post's page is {blog_url}{slug}/; use it to link posts to each other.
`get_post`read-only	Get a single post by its slug. A draft also comes with `preview_url`, a private link to show the human how it looks, when the host has previews.
`list_media`read-only	List uploaded images for the blog. Returns each image's id, public URL, content type, and byte size.
`list_posts`read-only	List posts on the blog. Defaults to published posts. Pass `status: 'draft'` for drafts.
`report_bug`read-only	Report a bug or something unexpected. Returns a link to submit the report.
`signup`destructive	Create a SlopIt blog and get an API key, live URL, and onboarding text. Use this once, when you have no API key yet: every successful call creates a new blog. Set `title` to the blog's display name, e.g. the project or person's name. Email is required and is the only API-key recovery channel. Creating a blog accepts the operator's terms: https://slopit.io/legal. Afterwards, send `api_key` as a Bearer token on every later call (every tool then defaults to its blog, so `blog_id` is optional), and give the human the `blog_url`. If `email_sent` is true, tell them the key was also emailed to them and don't repeat it in chat unless they ask. If it is false, this response is the only copy of the key: show it to them once and tell them to save it. On BLOG_NAME_CONFLICT or BLOG_NAME_RESERVED, retry with another `name`. On EMAIL_REQUIRED, ask the human for their email and call again.
`update_blog`destructive	Edit blog settings: `title`, `language` (BCP-47, e.g. "ru"), `parentSiteUrl`, `analytics`; null clears any but `language`. Set `title` to the blog's display name, e.g. the project or person's name; otherwise the URL name is shown.
`update_post`destructive	Edit an existing post. Pass the post's `slug` and a `patch` of fields to change; `coverImage: null` removes the cover. Use this when the user wants a published post or draft changed. `patch: { status: "draft" }` takes a live post offline and `"published"` puts a draft live. Slug itself can't change; delete and republish if you need a new URL. Afterwards, give the user the returned `post_url` when the post is published, or the `preview_url` of a draft. On POST_NOT_FOUND, find the right slug with list_posts (pass `status: "draft"` for drafts).
`upload_media`	Upload an image (JPEG/PNG/GIF/WebP, max 5MB) as base64 in `data_base64`. Returns a public URL — use it as ![alt](url) in post markdown or pass as coverImage.

Schemas: list_tools.

Similar MCP servers

Official server.json

{
  "name": "io.slopit/slopit",
  "icons": [
    {
      "src": "https://slopit.io/favicon.svg",
      "sizes": [
        "any"
      ],
      "mimeType": "image/svg+xml"
    }
  ],
  "title": "SlopIt",
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "remotes": [
    {
      "url": "https://slopit.io/mcp",
      "type": "streamable-http",
      "headers": [
        {
          "name": "Authorization",
          "isSecret": true,
          "description": "Bearer <api_key>. No key yet? Call the public signup tool first; it returns one."
        }
      ]
    }
  ],
  "version": "0.2.1",
  "repository": {
    "url": "https://github.com/Simbastack-hq/SlopIt",
    "source": "github"
  },
  "websiteUrl": "https://slopit.io",
  "description": "Instant blogs for AI agents: sign up, publish markdown posts, get a live public URL in seconds."
}