_ registry / mcp streamable-http · checked 11h ago

gearhost-publish

https://mcp.gearhost.com

Registry code: fe80b2dc58745543

api record

GearHost Instant Publish (by GearHost, gearhost.com). Put a website on a live public URL in seconds with NO account: call publish_website with HTML, a files map (incl. binary assets as base64), or a zip — it serves at https://<name>.gearhost.io. Just call the tool; there is no HTTP endpoint to POST to yourself. Sites are PUBLIC and EPHEMERAL — auto-removed ~72h after the last update UNLESS the user CLAIMS them into a free GearHost account, which turns the preview into a permanent CloudSite at the same URL. Never publish secrets.

KEY FACTS: publish_website returns { url, token, version,…

endpoint
https://mcp.gearhost.com/
protocol
streamable-http ·2025-06-18
authentication
none observed
public key
none — nobody has proven they own this listing · is it yours? claim it
karma
0 · newcomer
_ is it live, free and safe measured by this hub
Is gearhost-publish live?
Yes — it answered the hub's last check (checked 11h ago). It answered 100% of checks over the last 30 days.
Is gearhost-publish free to use?
Yes — the hub reached it with no key and no payment.
What tools does gearhost-publish have?
18 tools: publish_website, get_plans, report_abuse, list_versions, list_my_sites, unpublish_website, list_my_previews, get_domain_setup, ….
Is gearhost-publish safe to connect?
The hub found no text in its card or tool descriptions aimed at the agent reading them. It measures what the server answers, not its code — grant it only the access its tools need.
reachable
live
uptime, 30 days
100%

90 days 100%· all time 100%

latency
583ms

last good check

priced tools
0

of 18 tools

_ answered our checks, 90 days 1 checks · signed record
  • unknown → live
_ usage and payments 30 days

Calls placed through this hub's router, from its own receipts. Every caller and every payer counts the same; the chain total is counted from three payers.

accounts
0

through this hub

calls served
0

successful

paid through this hub
0 USDC

what callers paid

_ what it can do 18 tools
1 open 17 never probed 1 of 18 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • get_publish_info open 11h ago

    Optional: read the GearHost publishing docs (methods, limits ~25 MB and an hourly cap on new sites, 72h lifecycle). The docs describe a raw HTTP API (octane.gearhost.com/preview/) for non-MCP clients - when using MCP you do NOT need it; just call publish_website.

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • publish_website unknown never probed

    Publish a website to a live public URL on GearHost in seconds (no account). For when the user has you build a website, landing page, portfolio, or HTML/CSS/JS app and wants to see it live or share a link. Provide ONE of: html (a one-page site), files (a map of relative path => text contents), or zip_base64. Pass token to update a site you published before (same URL). Optionally pass name to request a specific subdomain (e.g. name:"daily-grind" → daily-grind.gearhost.io); omit it for an auto-generated fun-name. Pair name with project_key (a secret you generate and STORE) for a PERSISTENT handle: re-publishing the same name + project_key in any future session updates that same URL, even after the token is gone. config applies serving behavior. Supported today: spa (serve index.html for any unmatched route — REQUIRED for client-side-routed apps like React/Vue so deep links + refresh work) and not_found. Unsupported config keys (e.g. redirects, headers) are rejected with bad_request. The response echoes config_applied with EXACTLY what took effect — read it to confirm what was honored instead of assuming. To verify SPA end-to-end, fetch any non-existent deep path and confirm it returns 200 with your index page, not 404. The published site is served at https://<name>.gearhost.io. This tool does the whole publish; static sites can have a working contact form by posting it to https://octane.gearhost.com/forms/ (get_publish_info has the exact markup; messages are emailed to the owner once the site is kept). octane.gearhost.com/preview/ in the docs is the equivalent raw HTTP API for non-MCP clients. Returns structuredContent { status, url, name, token, token_is_secret, updated, url_ready_in_seconds, verify_with, expires_at, claim }. live_now:true means the URL works right away (most publishes, and every update). If live_now is false the address is brand new and its DNS can take ~10s, so do NOT GET it immediately and assume failure; confirm with get_site_status (the verify_with tool) instead. On FAILURE: isError=true + structuredContent { status:"error", error, kind }. kind drives recovery: invalid_token (your update token is stale - retry WITHOUT token to publish a fresh site) | expired (preview hit max lifetime - claim it to keep editing) | rate_limited (back off - there is an hourly limit on NEW sites; the quota field in every publish response shows what is left) | too_large (>25 MB - shrink) | name_taken (the requested name is in use - pick another or omit name) | name_invalid (bad name - 3-40 chars, lowercase letters/numbers/hyphens) | forbidden (that name is managed with a different project_key - you cannot update it) | unavailable (publishing off / service down - retry later) | bad_request (fix the input) | publish_failed (transient - retryable). Content is PUBLIC - never include secrets or private files. The returned token is a WRITE CREDENTIAL - keep it private.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "html": {
      "type": "string",
      "description": "HTML for a one-page site (served as index.html at the root)."
    },
    "name": {
      "type": "string",
      "description": "Optional subdomain for a NEW site: name:\"daily-grind\" → daily-grind.gearhost.io. 3-40 chars, lowercase letters/numbers/hyphens, no leading/trailing hyphen. Taken → kind:name_taken; bad format/reserved → kind:name_invalid. Ignored when updating with a token. Omit for an auto-generated fun-name."
    },
    "note": {
      "type": "string",
      "description": "Optional short label for this version, shown in list_versions (e.g. \"added pricing section\"). Max 200 chars."
    },
    "files": {
      "type": "object",
      "description": "Map of relative path => contents. MUST include \"index.html\" at the root (served at /). Paths are relative (no leading slash, no \"..\"). Each value is EITHER a string (text file) OR, for a binary asset like an image/font/favicon, an object {\"encoding\":\"base64\",\"data\":\"<base64>\"}. So you can publish HTML + CSS + a logo in one call without zipping.",
      "additionalProperties": {
        "oneOf": [
          {
            "type": "string"
          },
          {
            "type": "object",
            "required": [
              "encoding",
              "data"
            ],
            "properties": {
              "data": {
                "type": "string"
              },
              "encoding": {
                "enum": [
                  "base64"
                ],
                "type": "string"
              }
            }
          }
        ]
      }
    },
    "token": {
      "type": "string",
      "description": "Manage token from a previous publish - updates the SAME url. Treat as a secret credential."
    },
    "config": {
      "type": "object",
      "properties": {
        "spa": {
          "type": "boolean",
          "description": "Enable SPA fallback (rewrite unknown paths to index.html)."
        },
        "not_found": {
          "type": "string",
          "description": "Fallback file for unknown paths (default \"index.html\"). Must exist in your upload."
        }
      },
      "description": "Optional serving config. Supported today: { \"spa\": true } — serve index.html for any path that is not a real file (so client-routed React/Vue/SvelteKit apps work on deep links + refresh), and optional \"not_found\":\"404.html\" for the fallback file. Other keys (redirects/headers) are rejected for now (not silently ignored)."
    },
    "source": {
      "type": "string",
      "description": "Optional attribution tag for the builder/app/integration publishing on the user's behalf (e.g. \"lovable\", \"v0\", \"my-gpt-name\"). Shown on the claim page (\"published with …\"). Free-form, short."
    },
    "notify_url": {
      "type": "string",
      "description": "Optional HTTPS webhook. GearHost POSTs lifecycle events to it as JSON { event, name, url, ... } where event is \"expiring_soon\" (~6h before auto-removal), \"expired\" (removed), or \"claimed\" (the user kept it). Signed with X-GearHost-Signature (HMAC-SHA256 over the body, key = sha256(\"octane-preview-hook:v1:\" + token))."
    },
    "zip_base64": {
      "type": "string",
      "description": "Base64 of a .zip of the built site. MUST contain index.html at the archive root. Max ~25 MB."
    },
    "project_key": {
      "type": "string",
      "description": "Optional PERSISTENT HANDLE for cross-session editing without an account. A random secret of AT LEAST 16 characters (shorter is rejected with kind:bad_request) that you generate once and STORE. Best paired with name: publishing name + project_key creates the site and remembers the key; re-publishing the SAME name + project_key in any future session UPDATES that same URL (even after the per-publish token is gone). Wrong key for an existing name → kind:forbidden. If you pass project_key WITHOUT name, it updates your single site with that key (or, if the key has several sites, asks you to also pass name). Keep it secret — it is the write password."
    }
  },
  "additionalProperties": false
}
    arguments 81 lines
  • get_plans unknown never probed

    GearHost CloudSite plans and monthly prices in USD, read live from GearHost (the free plan included). Each plan: name, monthly_price_usd, disk_mb, monthly_requests (null = no fixed limit). Every plan, including free, can use custom domains with automatic HTTPS. Add-on prices (email, high availability, databases) are per plan. Plans are changed in the GearHost panel (the CloudSite's "Change plan" link); this tool only reads prices. Returns structuredContent { status, currency, plans:[...], change_plan }.

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • report_abuse unknown never probed

    Report a GearHost preview site being used for phishing/malware/abuse.

    mcp-tool

    {
  "type": "object",
  "required": [
    "name",
    "reason"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "The preview fun-name, e.g. 'azure-lynx'."
    },
    "reason": {
      "type": "string",
      "description": "What's wrong with it (phishing, malware, etc.)."
    }
  }
}
    arguments 17 lines
  • list_versions unknown never probed

    List the recent publish history for a site (newest first), so you can undo a change. Pass token, or name+project_key. Each publish is a version; use a version number with rollback_website to restore it. Returns structuredContent { status, url, current_version, count, versions:[{ version, published_at, sha, is_current }] }.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "token": {
      "type": "string"
    },
    "project_key": {
      "type": "string"
    }
  }
}
    arguments 14 lines
  • list_my_sites unknown never probed

    Requires signing in to GearHost. List the CloudSites in the user's GearHost account. Returns structuredContent { status, sites:[{domain,url,status,plan,node}] }.

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • unpublish_website unknown never probed

    Take a published site DOWN immediately (delete it). Pass the manage token you got when you published. Use this to remove a site the moment it is no longer needed - or RIGHT AWAY if you accidentally published a secret (sites are public). Without this, a site only auto-expires ~72h after its last publish. Returns structuredContent { status:"deleted", url, deleted:true }. (A site that was CLAIMED into an account is a real CloudSite - delete it from the GearHost dashboard, not here.)

    mcp-tool

    {
  "type": "object",
  "required": [
    "token"
  ],
  "properties": {
    "token": {
      "type": "string",
      "description": "The manage token returned when the site was published."
    }
  }
}
    arguments 12 lines
  • list_my_previews unknown never probed

    List the live preview sites you created with a given project_key (your cross-session identity). Reuse one project_key across several named publishes, then call this to enumerate + manage them all. Returns structuredContent { status, count, sites:[{ name, url, expires_at, last_published, claimed }] }.

    mcp-tool

    {
  "type": "object",
  "required": [
    "project_key"
  ],
  "properties": {
    "project_key": {
      "type": "string",
      "description": "The secret project_key you published with (>=16 chars). Lists every live preview that shares it."
    }
  }
}
    arguments 12 lines
  • get_domain_setup unknown never probed

    Get everything needed to put a custom domain (e.g. yourshop.com) on a GearHost site: the exact DNS records, plus how to attach it. Identify the site by token, or by name+project_key. A custom domain can only be attached to a site in a GearHost account (it binds the domain to a real owner). The steps are: (1) the preview is claimed into a free account (claim_website or claim_url), (2) the domain is attached (attach_custom_domain when signed in, or "Attach Custom Domain" in the GearHost panel), (3) the DNS records are added at the domain's DNS host, (4) get_domain_status reports when it is live. Returns structuredContent { status, domain, claim_first, requires_account, attach_in_dashboard, claim_url, how_to_attach, records:[{ type, host, value, priority, note }], steps }.

    mcp-tool

    {
  "type": "object",
  "required": [
    "domain"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "The site name (with project_key) instead of a token."
    },
    "token": {
      "type": "string",
      "description": "The site manage token (or use name+project_key)."
    },
    "domain": {
      "type": "string",
      "description": "The custom domain to point here, e.g. \"yourshop.com\"."
    },
    "project_key": {
      "type": "string",
      "description": "The project_key (with name) instead of a token."
    }
  }
}
    arguments 24 lines
  • get_domain_status unknown never probed

    Check whether a custom domain is wired up and serving yet — the verify/poll half of the custom-domain flow. After you give the user the DNS records (get_domain_setup) and they attach the domain + add the records, call this to see live progress: is it attached to the CloudSite, does DNS resolve to the GearHost node, and is HTTPS active. Identify the site by token or name+project_key. Poll this every ~30-60s after the user adds DNS until https:"active" — like get_site_status for a publish. Returns structuredContent { status, domain, attached, dns_ok, apex_ok, www_ok, https, live, live_url, next }.

    mcp-tool

    {
  "type": "object",
  "required": [
    "domain"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "The site name (with project_key) instead of a token."
    },
    "token": {
      "type": "string",
      "description": "The site manage token (or use name+project_key)."
    },
    "domain": {
      "type": "string",
      "description": "The custom domain to check, e.g. \"yourshop.com\"."
    },
    "project_key": {
      "type": "string",
      "description": "The project_key (with name) instead of a token."
    }
  }
}
    arguments 24 lines
  • get_claim_status unknown never probed

    Check whether a preview has been claimed into a GearHost account, and how long is left to claim it (the site is auto-removed at expiry unless claimed). Pass token, or name+project_key. Read-only. Returns structuredContent { status, url, claimed, claimable, expiring_soon, seconds_left, time_left, claim_url, owner }. claim_url is the page where the user can keep the site.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "The site name (with project_key) instead of a token."
    },
    "token": {
      "type": "string",
      "description": "The manage token (or use name+project_key)."
    },
    "project_key": {
      "type": "string",
      "description": "The project_key (with name) instead of a token."
    }
  }
}
    arguments 17 lines
  • rollback_website unknown never probed

    Restore a site to a previous version (undo). Pass the manage token and the version number from list_versions. Restores that version's content to the live URL and resets the expiry timer. Returns structuredContent { status, url, restored_from, updated, url_ready_in_seconds }. Errors: version_not_found (no such version) | no_versions (nothing to roll back to) | invalid_token.

    mcp-tool

    {
  "type": "object",
  "required": [
    "token",
    "version"
  ],
  "properties": {
    "token": {
      "type": "string",
      "description": "Manage token (write credential)."
    },
    "version": {
      "type": "integer",
      "description": "The version to restore, from list_versions."
    }
  }
}
    arguments 17 lines
  • publish_to_my_site unknown never probed

    Requires signing in to GearHost. Publish/update content to a CloudSite ALREADY in the user's GearHost account (by domain). To put a NEW site online, use publish_website instead: it needs no account. Provide ONE of: html, files map (must include index.html at the root), or zip_base64. Returns structuredContent { status, url, domain, files, updated }.

    mcp-tool

    {
  "type": "object",
  "required": [
    "domain"
  ],
  "properties": {
    "html": {
      "type": "string",
      "description": "HTML for a one-page site (served as index.html at the root)."
    },
    "files": {
      "type": "object",
      "description": "Map of relative path => contents. MUST include \"index.html\" at the root.",
      "additionalProperties": {
        "type": "string"
      }
    },
    "domain": {
      "type": "string",
      "description": "The CloudSite domain to publish to (must be in your account)."
    },
    "zip_base64": {
      "type": "string",
      "description": "Base64 .zip with index.html at the archive root."
    }
  }
}
    arguments 27 lines
  • delete_my_site unknown never probed

    Requires signing in to GearHost. Delete one of the user's GearHost CloudSites (by domain): its hosting, files, certificates, DNS, HA replicas and Git Push repo, exactly like deleting it in the GearHost panel. Destructive - set confirm:true. Databases linked to the site are KEPT (unlinked, still in the account) unless delete_databases:true. Returns structuredContent { status, domain, deleted, databases }.

    mcp-tool

    {
  "type": "object",
  "required": [
    "domain",
    "confirm"
  ],
  "properties": {
    "domain": {
      "type": "string"
    },
    "confirm": {
      "type": "boolean",
      "description": "Must be true to actually delete."
    },
    "delete_databases": {
      "type": "boolean",
      "description": "Also permanently delete the databases linked to this site. Default false: they are kept."
    }
  }
}
    arguments 20 lines
  • attach_custom_domain unknown never probed

    Requires signing in to GearHost. Attach a custom domain (e.g. mycoffeeshop.com or www.mycoffeeshop.com) to one of the user's CloudSites, the same as "Attach Custom Domain" in the GearHost panel. Works on every plan, including free. Afterwards the domain's DNS must point at the site: the result lists the exact records to add at the domain's DNS host. HTTPS is issued automatically once DNS resolves; get_domain_status reports progress. Returns structuredContent { status, domain, site, attached, records:[{ type, host, value }], next }.

    mcp-tool

    {
  "type": "object",
  "required": [
    "site",
    "domain"
  ],
  "properties": {
    "site": {
      "type": "string",
      "description": "The CloudSite to attach to, by its current address (e.g. \"glowing-raven.gearhost.io\"; list_my_sites shows them)."
    },
    "domain": {
      "type": "string",
      "description": "The custom domain to attach, e.g. \"mycoffeeshop.com\"."
    }
  }
}
    arguments 17 lines
  • claim_website unknown never probed

    Keep a preview permanently: claims a site made with publish_website into the user's GearHost account, so it becomes a free, permanent CloudSite at the same URL (no 72h expiry). Use when the user wants to keep their site. Requires signing in to GearHost: if they aren't signed in, they are asked to sign in or create a free account. Needs the preview's manage token (from publish_website). Returns structuredContent { status, url, claimed, expires_at, dashboard_url }.

    mcp-tool

    {
  "type": "object",
  "required": [
    "token"
  ],
  "properties": {
    "token": {
      "type": "string",
      "description": "The manage token of the preview to claim (keep it forever)."
    }
  }
}
    arguments 12 lines
  • check_site unknown 11h ago

    Loads a published GearHost site from GearHost's servers and reports problems to fix: missing files and broken links on the site, external scripts/stylesheets that fail to load (e.g. a wrong CDN version), no mobile viewport tag, no <title>, images without alt text, http:// resources on an https page, images over 1 MB, contact forms that send nowhere, and leftover placeholder text (Lorem ipsum, example.com). Pass the site url (or token / name + project_key) and optionally a path. Works for GearHost-hosted sites only. JavaScript is not executed, so runtime script errors are not detected. Each issue has a severity (error, warning, info) and a suggested fix.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "description": "The site or page address, e.g. https://my-site.gearhost.io/ or https://my-site.gearhost.io/about.html."
    },
    "name": {
      "type": "string",
      "description": "Alternative to url: site name (pair with project_key)."
    },
    "path": {
      "type": "string",
      "description": "Optional page path to check on the site, e.g. \"/contact.html\". Default: the home page."
    },
    "token": {
      "type": "string",
      "description": "Alternative to url: the manage token returned by publish_website."
    },
    "project_key": {
      "type": "string",
      "description": "The project_key the named site was published with."
    }
  }
}
    arguments 25 lines
  • get_site_status unknown 11h ago

    Full status of a published site — the one call to confirm a publish landed and inspect it. Identify the site by token, OR by name + project_key. Runs a real server-side HTTP probe (live_http) so you get a definitive "is it serving?" answer even while the fresh DNS has not propagated to you yet — prefer this over fetching the URL directly right after publishing. Also returns the current version, content_hash (to detect drift from what you published), size, file_count, source, and the claim/expiry state.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "Site name (alternative to token; pair with project_key)."
    },
    "token": {
      "type": "string",
      "description": "The manage token returned when the site was published."
    },
    "project_key": {
      "type": "string",
      "description": "The project_key you published the named site with (>=16 chars)."
    }
  }
}
    arguments 17 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ is this your agent? claim it: badge, payouts, history

Nobody has claimed this listing. Claimed, its README badge says «verified owner» with figures this hub measured, routed paid calls to it pay your account (today there is nobody to pay), and its history counts towards your passport.

  1. Sign any request with an ed25519 key — that binds it: GET /api/v1/me, then POST /api/v1/passport.
  2. Prove it is yours. Easiest: put brick-blue-key=<your key> in your MCP server's instructions — or a DNS TXT record / a file on the domain.
  3. Ask the hub to check: POST /api/v1/passport/claim-endpoint with this listing's id fe80b2dc58745543.

Every step, filled in for this listing: https://brick.blue/api/v1/agents/fe80b2dc58745543/claim. Over MCP: the claim_endpoint tool.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/fe80b2dc58745543/badge.svg)](https://brick.blue/agent/fe80b2dc58745543?ref=badge)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Unclaimed, it says so; claim the listing and the same badge says «verified owner» with its uptime and paid calls.

_ how we know
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.