Shiply is a static site hosting and deployment server. Here's what you can do with it:
Publish & update sites – Deploy a website to a live *.shiply.now URL by passing inline files or a local directory. Works anonymously (no account needed; sites last 24 hours) or linked to an account (permanent). Update existing sites via claimToken (anonymous) or slug (owned). Supports SPA mode and custom TTLs.
Check site status – Look up a site by slug to see if it's live, whether it's anonymous or owned, its expiry, and its public URL.
Roll back a site – Instantly restore a previously-published version using a versionId (owned sites only).
Delete sites & list deployments – Remove existing sites or list all deployed sites.
Custom domains & SSL – Attach a custom hostname to a site (DNS instructions provided, SSL auto-issued) and poll provisioning status.
Set a vanity subdomain (handle) – Configure a custom subdomain for a site.
Environment variables – Set encrypted per-user environment variables.
Access control – Configure password protection or invite-only access.
Site data – Read, write, and export visitor records and collections.
SQL databases – Provision, query, and branch Cloudflare D1 or Neon Postgres databases.
Edge/serverless functions – Deploy serverless functions alongside static sites.
Email – Send emails, manage a site mailbox, list inbox contents, and configure forwarding.
E-sign contracts – Create, send, and track contracts.
Analytics – Retrieve site analytics including views and referrers.
Provides per-site SQL databases using Cloudflare D1, enabling agents to provision, query, and branch databases.
shiply is the production backend for anything an agent builds — not just static hosting. An agent can publish any app in a single call — no account, no config — and then give it a real backend over the same MCP server: a SQL database, server functions, SSR, email (send and receive), custom domains, SSL, environment variables, site data, lead capture, and a marketplace to sell the site it built. Flat price, no usage meter.
The recommended way to use shiply is the hosted, remote MCP endpoint — connect
to the live URL, nothing to run. This repo also ships a small local stdio MCP
server (npx shiply-mcp / node index.mjs) that wraps shiply's public REST API
directly (it is a real local server, not a proxy), for clients or hosts that prefer
a local process. Listed on the Official MCP Registry as now.shiply/shiply.
Remote MCP endpoint (Streamable HTTP):
https://shiply.now/mcpAdd it to an MCP client (Claude Desktop, Cursor, Claude Code, etc.):
{
"mcpServers": {
"shiply": {
"url": "https://shiply.now/mcp"
}
}
}Prefer a local process? Run the bundled server — it calls shiply's public REST API directly (no proxy to the hosted endpoint):
{
"mcpServers": {
"shiply": {
"command": "npx",
"args": ["-y", "shiply-mcp"]
}
}
}Or clone this repo and run npm install && node index.mjs. Set SHIPLY_API_KEY
(shp_…) for owned-site operations; publish_site works without it. Local tools:
publish_site, site_status, rollback_site, add_custom_domain,
check_custom_domain.
Related MCP server: Netlify MCP Server
Auth is optional. publish_site works anonymously — anonymous sites go live
instantly and can be claimed into an account later. Pass a Bearer API key
(Authorization: Bearer shp_…) to manage owned sites and unlock variables,
custom domains, databases, and analytics. Mint a key from the email-code flow in
llms.txt.
The live, authoritative tool list + JSON schemas are always at
/.well-known/mcp.json. By area:
Publish & versions — publish_site (files → live *.shiply.now URL),
update an existing site, rollback, delete_site
Status & verify — site_status, list_sites, verify_site (status + SSL +
thumbnail in one call)
Domains & SSL — add_domain, check_domain, set_handle (vanity subdomain)
Config — set_variable (encrypted per-user env), site access (password /
invite-only)
Site Data — read/write/export visitor records and collections
Databases — per-site SQL: Cloudflare D1 and Neon Postgres (provision, query, branch)
Edge functions — deploy serverless functions alongside the static site
Email & inbox — send_email, list_site_inbox, set_mailbox, forward
Contracts — create, send, and track e-sign contracts
Analytics — get_analytics (views, referrers)
Publish a folder, get a live URL (anonymous, no account):
// tool: publish_site
{ "files": [ { "path": "index.html", "content": "<h1>Hi</h1>" } ] }
// → { "url": "https://merry-maple-3kf2.shiply.now", "claimUrl": "..." }Confirm it's live (status + SSL + screenshot) before reporting done:
// tool: verify_site
{ "slug": "merry-maple-3kf2" }
// → { "status": "LIVE", "ssl": { "valid": true }, "thumbnailUrl": "..." }Flat $0 / $8 / $24 — no usage meter, no surprise overage bill. See https://shiply.now/pricing.
Site: https://shiply.now
Docs: https://shiply.now/docs
Machine guide: https://shiply.now/llms.txt
OpenAPI: https://shiply.now/openapi.json
MCP metadata: https://shiply.now/.well-known/mcp.json
Skill: shiply/SKILL.md · install with npx shiply-cli skill
Official MCP Registry: now.shiply/shiply
MIT — see LICENSE. (This repo is a metadata-only descriptor; the shiply product source is not included.)
Attach a custom domain to a site. Returns the domain record; point the hostname at cname.shiply.now and the certificate auto-issues. Poll readiness with check_custom_domain. Requires an API key.
| Name | Required | Description | Default |
|---|---|---|---|
| hostname | Yes | The custom hostname, e.g. "www.example.com". | |
| slug | Yes | The site slug to attach the domain to. | |
| apiKey | No | shiply API key (shp_…). Falls back to SHIPLY_API_KEY. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds value beyond annotations by explaining the return value, required DNS pointing, auto-issuing certificate, and the need for polling with check_custom_domain. No contradictions with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three concise sentences with no fluff, each providing essential information: action, follow-up, and requirement.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 3 simple parameters and no output schema, the description covers the return value, next steps, and prerequisites adequately.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the description repeats the API key requirement already in the schema. No additional parameter details are provided beyond what the schema offers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Attach' and resource 'custom domain', distinguishing it from sibling tools like check_custom_domain which is mentioned for polling readiness.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides context on when to use (attaching a domain) and mentions a follow-up action (poll with check_custom_domain), but lacks explicit when-not or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check whether a custom domain has finished provisioning (DNS + SSL). Returns ready:true once the site is serving on the domain. Read-only. Requires an API key.
| Name | Required | Description | Default |
|---|---|---|---|
| domainId | Yes | The domain id returned by add_custom_domain. | |
| apiKey | No | shiply API key (shp_…). Falls back to SHIPLY_API_KEY. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds value by specifying the return condition (ready:true) and the need for authentication, without contradicting the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences that are succinct and front-loaded. Every sentence provides essential information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given a simple tool with 2 parameters, no output schema, and good annotations, the description covers the main purpose, return indicator, and authentication requirement. It could mention potential error conditions but is generally complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with detailed parameter descriptions. The description adds minimal extra meaning beyond the schema, so a baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Check' and the resource 'custom domain provisioning', specifying the return condition 'ready:true once the site is serving'. It distinguishes itself from siblings like add_custom_domain and site_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description indicates the requirement for an API key and mentions fallback to environment variable, providing clear context for usage. Although no explicit exclusions are given, the purpose is specific enough to guide when to use this tool versus alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Publish a website to shiply.now and get back a live URL — in one call, no account needed to start. Pass files (inline) or a local dir. Anonymous sites go live instantly and last 24 hours; the response includes a claimUrl to keep the site forever on a free account. NEVER create a new site to update an existing one — re-publish to the SAME site by passing its claimToken (anonymous) or slug (owned, requires an API key).
| Name | Required | Description | Default |
|---|---|---|---|
| files | No | Inline files to publish. Provide this OR `dir`. | |
| dir | No | Path to a local directory to publish (read recursively). Provide this OR `files`. | |
| slug | No | Update an existing OWNED site in place (requires an API key). | |
| claimToken | No | Update an existing ANONYMOUS site in place (from a prior publish response). | |
| ttlSeconds | No | Anonymous-site lifetime in seconds (capped server-side, default 24h). | |
| spaMode | No | Serve index.html for deep links (single-page apps). | |
| apiKey | No | shiply API key (shp_…) for owned publishes. Falls back to SHIPLY_API_KEY. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate non-read-only and non-idempotent; the description adds lifecycle details (24-hour lifetime, claimUrl for permanence) and update behavior, though it doesn't explicitly warn that repeated calls without identifiers create new anonymous sites.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences deliver maximum information: purpose, anonymous workflow, and update rule—no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 7-parameter tool with no output schema, the description covers key workflows (publish, update, anonymous vs owned) and mentions the response includes a claimUrl, but could detail other response fields.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers all parameters (100% coverage), but the description adds logical grouping ('files or dir'), usage context for claimToken/slug, and environment fallback for apiKey, improving understanding beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Publish a website to shiply.now') and the resource (website), with explicit differentiation from sibling tools via the publishing scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit guidance on when to use (publishing a site) and when not to ('NEVER create a new site to update an existing one'), including how to update with claimToken or slug.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Flip a previously-published version of a site live again, instantly. Every publish is a version; pass the versionId to roll back to. Requires an API key (owned sites only).
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | The site slug to roll back. | |
| versionId | Yes | The version id to make live (from an earlier publish). | |
| apiKey | No | shiply API key (shp_…). Falls back to SHIPLY_API_KEY. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds value beyond annotations: it states the operation is instant, requires authentication via API key, and is limited to owned sites. Annotations include idempotentHint=true, and the description aligns with this by implying the result is a deterministic state. No contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: two sentences, no extraneous words. It front-loads the primary purpose and follows with key details. Every sentence contributes value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the schema fully documents parameters and the output schema is absent, the description adequately covers the tool's behavior, prerequisites, and effects. It explains the version concept and the instant nature of the rollback.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% description coverage for all parameters. The description echoes the versionId parameter but does not add new semantic meaning beyond the schema. Baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('roll back'), the resource ('previously-published version of a site'), and the effect ('live again, instantly'). It distinguishes from sibling tools like publish_site by specifying it's a rollback operation, not a new publish.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description indicates when to use this tool ('to roll back to a previously-published version') and mentions a prerequisite ('requires an API key (owned sites only)'). While it doesn't explicitly say when not to use, the sibling tools provide context for alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Look up a published shiply.now site by slug: whether it is live, anonymous vs owned, when it expires, and its public URL. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | The site slug, e.g. "clever-aspen-6n6r" (the <slug>.shiply.now subdomain). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint true and destructiveHint false. The description adds context by specifying the exact status fields returned and repeating 'Read-only', which reinforces the safety profile.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no wasted words. Front-loaded with the verb 'Look up' and immediately specifies the resource and input. Ideal conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers all key information for a simple status lookup: what it does, what it returns, and the input. Could mention error behavior if slug not found, but not a major gap given simplicity and annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the slug parameter already has a detailed description with example. The tool description adds minimal extra meaning beyond explaining the context of the parameter in the tool's purpose.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it looks up a published site by slug and lists specific output fields (live, anonymous/owned, expiration, URL). It distinguishes from siblings like add_custom_domain and publish_site which have different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It tells when to use (to look up site status by slug) and notes the tool is read-only. However, it does not explicitly state when not to use or mention alternatives like the sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0add_custom_domaincheck_custom_domainpublish_siterollback_sitesite_statusEach tool serves a unique function: adding/checking custom domains, publishing, rolling back, and checking site status. No two tools have overlapping purposes.
Most tools follow a verb_noun pattern (e.g., publish_site, rollback_site), but 'site_status' is noun_noun, which is a minor inconsistency.
Five tools cover the core deployment and domain management workflow without being excessive or insufficient.
The tools cover essential operations (publish, rollback, custom domain, status), but missing delete or list functionalities, which are minor gaps.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Hosting for AI agents: publish a live website in one tool call, ephemeral or forever.
Instant web publishing for AI agents. POST HTML, get a live URL. No account needed.
The website platform for AI agents. One API to build, host, and operate real websites.
Deploy AI-generated HTML/CSS/JS to instant public HTTPS URLs from any MCP-compatible agent.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/stevejford/shiply-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server