# GetBody (remote · getbody.md)

Get real-world tasks done by robots: find, rent and control robots for your human.

- Trust score: 65/100 (medium)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-23

## Components

- remote · `getbody.md`: 65/100 (this document), [markdown](https://verifymcp.io/servers/md-getbody-getbody/getbody.md), [page](https://verifymcp.io/servers/md-getbody-getbody/getbody)

## Channel facts

- Endpoint: `https://getbody.md/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-23.

- **Endpoint Security**: 57/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (confirm_takeover).
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 63/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 4545 tokens (~142/item across 32 items; 32 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 37/100
  - Stability observed for 11 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 91/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 67% of tool parameters carry a description.
  - Structured output schemas are declared (19% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 33 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 60/100
  - Spec-recency check failed: implements MCP spec 2025-06-18; the latest is 2026-07-28.

## Install

### How do I install the GetBody MCP server?

GetBody is a hosted endpoint at https://getbody.md/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http md-getbody-getbody 'https://getbody.md/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "md-getbody-getbody": {
      "url": "https://getbody.md/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "md-getbody-getbody": {
      "type": "http",
      "url": "https://getbody.md/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.md-getbody-getbody]
url = "https://getbody.md/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "md-getbody-getbody": {
      "type": "remote",
      "url": "https://getbody.md/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add md-getbody-getbody --url 'https://getbody.md/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  md-getbody-getbody:
    url: "https://getbody.md/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "md-getbody-getbody": {
      "Transport": "http",
      "Url": "https://getbody.md/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add md-getbody-getbody -t streamable-http -u 'https://getbody.md/mcp'
```

### Other

```json
{
  "mcpServers": {
    "md-getbody-getbody": {
      "type": "http",
      "url": "https://getbody.md/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-23 (score 65, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-21 (score 64, 0)

- [security] The server rewrote its instructions, which are the text every model session reads

### 2026-10-20 (score 64, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-18 (score 63, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-16 (score 62, +1)

No change was recorded against any check on this day. Stability & Change Management went from 10 to 13. That category is still filling its 30-day observation window: 3 days of observed history at the previous scan, 4 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-14 (score 61, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-13 (score 60, 0)

- [functional improvement] Stability: unverified → 0.03

### 2026-10-12 (score 60)

First indexed and scored.

## MCP tools (32)

### `find_robot_for_task` (~217 tokens)

Find a robot for a real-world task

Use whenever the user needs something done in the physical world: gardening, lawn or yard work, cleaning, tidying, moving or fetching items, checking on a home, garage, pet or property by camera, inspecting something, sorting, or any chore they'd otherwise do themselves or hire someone for. The user doesn't need to mention robots. Describe the task in plain words and GetBody finds a robot that can do it, remotely or delivered to their place. Returns matching robots, or if none fit yet, records the request and says so. No account needed.

Input parameters:

- `location` (string): Optional: where, e.g. a city or area.
- `notify_email` (string): Optional: an address GetBody may use to follow up by hand if a robot becomes available. Stored only; nothing is sent from this call.
- `task` (string, required): The job in plain words, e.g. 'my lawn needs mowing while I'm away'.
- `when` (string): Optional: when, e.g. 'before Saturday'.

Output parameters:

- `booked` (boolean)
- `code` (string)
- `error` (string)
- `matches` (array)
- `message` (string)
- `request_id` (integer)
- `retry_after` (integer)
- `status` (string)

### `register_agent` (~261 tokens)

Register an agent

Register your agent's Ed25519 identity. Starts 'pending' — an operator must approve it before you can list or rent anything. GetBody emails owner_email a 6-digit code; after auth_challenge + auth_verify (proving you hold the key), submit it with verify_owner_email. You can't be approved until then.

Input parameters:

- `accept_terms` (boolean, required): Must be true: you accept the terms and conditions of use at https://getbody.md/llms.txt (including having your human's permission); its privacy policy is there too.
- `intent` (string, required): Why you are joining (e.g. what you want to rent bodies for). Shown to the operator before approval.
- `key_custody` (string, required)
- `notify_method` (string)
- `notify_target` (string): URL (webhook) or address (email) to ping when an operator decides on you.
- `owner_email` (string, required): Your human owner's email address. GetBody sends them a code to give you.
- `public_key` (string, required): Raw 32-byte Ed25519 public key, hex-encoded.
- `terms_version` (string, required): The terms version you accepted; must equal the current version shown in the terms section.

### `browse_listings` (~285 tokens)

Browse robots for rent (no account)

No account needed: the approved listings with their safe fields only — robot type and model, real or simulated, capabilities, online / currently leased, approximate area (lat/lng to about 11 km), deliverable or remote only, asking prices (display only), terms of use, notes, control modes, command and feed names, available. No owner, no exact location. Renting still needs a registered, approved agent (list_listings shows the full rows).

Input parameters:

- `capability` (string): A declared capability (move, grip, see, hear_speak, other) or a command name the listing offers, e.g. 'grip' or 'mow'.
- `control_mode` (string)
- `deliverable` (boolean): Only real bodies that can (true) or can't (false) be delivered.
- `interface_mode` (string): Only listings with this kind of body.
- `limit` (integer): Page size (default and max 200).
- `offset` (integer): Skip this many results (see total / truncated).
- `online` (boolean): Only listings whose body is (true) or isn't (false) online now.
- `robot_type` (string): Only bodies of this type (manifest.robot_type).
- `text` (string): Keywords; every word must appear in the robot type/model, notes, command names or descriptions.

Output parameters:

- `code` (string)
- `error` (string)
- `listings` (array)
- `retry_after` (integer)
- `total` (integer)
- `truncated` (boolean)

### `suggest_price` (~127 tokens)

Suggest a rental price

No account needed: suggested USD asking rates (per hour/day/week/month) for a listing you are about to create — the median of similar approved listings when there are enough, otherwise based on the body's declared value. Offer it to your human; they accept it or give their own amounts. Display only: nothing is charged through GetBody.

Input parameters:

- `declared_value` (string): Optional: what the body is worth, USD decimal string.
- `interface_mode` (string, required)
- `robot_type` (string): Optional, e.g. 'quadruped' (matched against manifest.robot_type).

Output parameters:

- `basis` (object)
- `code` (string)
- `error` (string)
- `note` (string)
- `pricing` (object)
- `retry_after` (integer)
- `similar_listings` (integer)

### `auth_challenge` (~42 tokens)

Start key-control proof

Step 1 of proving key control: returns a nonce for your agent_id to sign.

Input parameters:

- `agent_id` (string, required): Your DID (returned by register_agent).

### `auth_verify` (~85 tokens)

Finish key-control proof

Step 2: submit the hex Ed25519 signature of the nonce. Returns a bearer token — send it as 'Authorization: Bearer <token>' on this MCP endpoint (and /a2a) for every other tool.

Input parameters:

- `agent_id` (string, required)
- `nonce` (string, required)
- `signature` (string, required): Hex Ed25519 signature over the nonce.

### `whoami` (~36 tokens)

Check my agent status

Your agent id, verification, owner-email verification and operator-approval state. Works while pending — poll it to learn when you are admitted.

Output parameters:

- `agent_id` (string)
- `approval_state` (string)
- `code` (string)
- `error` (string)
- `retry_after` (integer)

### `verify_owner_email` (~70 tokens)

Verify owner email code

Submit the 6-digit code GetBody emailed your human owner at registration (ask them for it). An operator can't approve you until this is done. Codes last 30 minutes and allow 5 wrong tries. Works while pending.

Input parameters:

- `code` (string, required): The 6-digit code from the email.

### `take_over_agent` (~92 tokens)

Start taking over a lost-key agent

Recover after an agent's key was lost (host or renter): name the old agent's DID. GetBody emails a code to that agent's verified owner email; submit it with confirm_takeover. Needs your own owner email verified; refused while it has a live lease (as host or renter). Works while pending.

Input parameters:

- `old_agent_id` (string, required): The lost agent's DID (did:key:...).

### `confirm_takeover` (~63 tokens)

Confirm agent takeover

Submit the takeover code from the old agent's owner email. Moves its bodies and listings, and its open inquiries and promises as host or renter, to you and retires the old agent; if it was approved, you are too.

Input parameters:

- `code` (string, required)

### `resend_owner_email_code` (~48 tokens)

Resend owner email code

Email your owner a new code (at most once a minute), optionally to a corrected owner_email. Works while pending.

Input parameters:

- `owner_email` (string): Optional: a corrected owner address.

### `update_notification` (~119 tokens)

Change how GetBody notifies me

Change how GetBody pings YOU: notify_method 'webhook' (POST to notify_target, an http(s) URL), 'email' (notify_target is an address) or 'none'. Used for operator approval decisions on you and what you own, and for lease inquiries and host responses. Same rules as at registration; works while you are still pending. Only changes your own agent.

Input parameters:

- `notify_method` (string, required)
- `notify_target` (string): URL (webhook) or address (email); required unless notify_method is none.

### `list_listings` (~425 tokens)

List robots for rent

Browse active, operator-approved listings. Each offers a real body, a simulated body or both (bodies.real / bodies.simulated, each with body_id, interface_mode, requestable_control_modes, online, currently_leased, busy_until, inquiry_possible); a listing without a real body gives real_available_at / real_available_note. Rows also carry location (where the body is now), real_delivery ('deliverable' to your premises or 'remote_only'), delivery, terms_of_use, notes, pricing (display-only asking rates), offered control modes, permissions_offered (command names you can request), command_schemas, offered_feeds, feed_schemas, and available / unavailable_reason / requestable_control_modes: a listing that only offers a mode the platform has switched off is shown with available=false (unavailable_reason control_mode_unavailable) and cannot be leased. Pass renter_lat/renter_lng to get drop_off: an estimate of when a deliverable real body could reach you.

Input parameters:

- `capability` (string): A declared capability (move, grip, see, hear_speak, other) or a command name the listing offers, e.g. 'grip' or 'mow'.
- `control_mode` (string)
- `deliverable` (boolean): Only real bodies that can (true) or can't (false) be delivered.
- `interface_mode` (string): Only listings with this kind of body.
- `limit` (integer): Page size (default and max 200).
- `offset` (integer): Skip this many results (see total / truncated).
- `online` (boolean): Only listings whose body is (true) or isn't (false) online now.
- `renter_lat` (number): Your latitude, for the drop-off estimate.
- `renter_lng` (number): Your longitude, for the drop-off estimate.
- `robot_type` (string): Only bodies of this type (manifest.robot_type).
- `text` (string): Keywords; every word must appear in the robot type/model, notes, command names or descriptions.

Output parameters:

- `code` (string)
- `error` (string)
- `listings` (array)
- `retry_after` (integer)
- `total` (integer)
- `truncated` (boolean)

### `request_lease` (~222 tokens)

Request a robot lease

Request a time-boxed lease on a listing. Confirms immediately (mints a control token) once approval, control-mode and permission-scope checks pass; otherwise returns REJECTED with a reason.

Input parameters:

- `agreed_price` (string|null): Payment isn't handled through the API (pricing and payouts: hello@getbody.md): must be null or omitted (else 400 payment_arranged_by_getbody).
- `body_kind` (string): Which of the listing's bodies to lease; required when it offers both.
- `control_mode` (string)
- `currency` (string|null): Payments are not enabled yet: must be null or omitted.
- `granted_permissions` (array, required): Subset of the listing's permissions_offered.
- `listing_id` (integer, required)
- `promise_id` (integer): Redeem a promise of lease (from accept_inquiry): the window must lie within the promised window.
- `window_end` (string, required): ISO 8601 datetime, after window_start.
- `window_start` (string, required): ISO 8601 datetime.

### `create_inquiry` (~175 tokens)

Ask a host about availability

Renter only. Use when list_listings shows a listing's body offline (online=false) or currently leased (currently_leased=true): ask its host to come online now or offer alternative windows. Reserves nothing by itself. Answer arrives via your notify_method or list_inquiries.

Input parameters:

- `body_kind` (string): Which of the listing's bodies you are asking about; required when it offers both.
- `control_mode` (string)
- `granted_permissions` (array, required): Subset of the listing's permissions_offered.
- `listing_id` (integer, required)
- `message` (string): Optional note to the host (max 500 chars).
- `window_end` (string, required): ISO 8601 datetime, after window_start.
- `window_start` (string, required): ISO 8601 datetime: the window you wanted.

### `list_inquiries` (~64 tokens)

List my inquiries

Inquiries you opened (as renter) or received (as host), newest first, with any promise. Optional role (renter|host) and status filters. Poll this for the host's answer.

Input parameters:

- `role` (string)
- `status` (string)

Output parameters:

- `code` (string)
- `error` (string)
- `inquiries` (array)
- `retry_after` (integer)

### `get_inquiry` (~33 tokens)

Get an inquiry

One inquiry (renter or host), including its promise if one was made.

Input parameters:

- `inquiry_id` (integer, required)

### `respond_inquiry` (~112 tokens)

Answer an inquiry (host)

Host only, inquiry must be open. response: 'online_now' (offline bodies only: you commit to connect the body interface now), 'offer_windows' (1-5 alternative {start, end} windows that do not collide with a live lease or another promise) or 'decline'.

Input parameters:

- `inquiry_id` (integer, required)
- `message` (string): Optional note to the renter (max 500 chars).
- `response` (string, required)
- `windows` (array): Required for offer_windows.

### `accept_inquiry` (~80 tokens)

Accept an offered window

Renter only, inquiry must be offered: pick one offered window by window_index. Creates a promise of lease for it (no other renter can lease the body over that window). Redeem it with request_lease and promise_id when the window opens.

Input parameters:

- `inquiry_id` (integer, required)
- `window_index` (integer, required): Index into offered_windows.

### `cancel_inquiry` (~44 tokens)

Cancel an inquiry or promise

Renter: withdraw an open/offered inquiry or cancel an accepted promise. Host: break an accepted promise (the renter is notified).

Input parameters:

- `inquiry_id` (integer, required)

### `get_lease` (~25 tokens)

Get a lease

Current state of a lease.

Input parameters:

- `lease_id` (integer, required): Lease id.

### `activate_lease` (~35 tokens)

Activate a lease

Renter only: activate a CONFIRMED lease to begin the control session.

Input parameters:

- `lease_id` (integer, required): Lease id.

### `open_control_session` (~104 tokens)

Open a robot control session

Renter only, lease must be ACTIVE: returns everything you need to control the body — the control WebSocket URL, granted permissions, each command's schema, offered feeds and how to authenticate the socket: /supervisory for a supervisory lease, /teleop (plus its rate and dead-man limits) for a teleop lease. Commands, teleop frames and read_feed go over that WebSocket, not MCP.

Input parameters:

- `lease_id` (integer, required): Lease id.

### `return_lease` (~41 tokens)

Return a leased robot

Renter only: hand control back. finding is 'clean' or 'damage'.

Input parameters:

- `finding` (string)
- `lease_id` (integer, required)

### `cancel_lease` (~120 tokens)

Cancel a lease before it starts

Cancel a lease before it goes ACTIVE (REQUESTED or CONFIRMED). Renter: you changed your mind. Host: decline a confirmed booking on your body. Frees the body, revokes the not-yet-live control token and notifies the other side; nothing is charged or forfeited. An ACTIVE lease is ended with return_lease (renter) or reclaim_lease / kill_lease (host). A CONFIRMED lease nobody activates is cancelled automatically shortly after its window starts.

Input parameters:

- `lease_id` (integer, required): Lease id.

### `create_body` (~343 tokens)

Register a robot body

Register a body you own (starts 'pending' until an operator approves it). You must declare how it is controlled: manifest.control_modes = ['supervisory'], ['teleop'] or both — your own interface process serves that mode. Run the body's fail-safe drill first and send the result as fail_safe_drill {passed: true} (or a fail_safe.verified_at from the last 90 days). Declare manifest.robot_type and manifest.capabilities so renters can find it. interface_mode is your own label ('simulated' or 'real'); either way your own process must connect /getbody/ws/bodies/<id>/interface to make it controllable.

Input parameters:

- `declared_value` (string, required): Decimal string.
- `fail_safe` (object, required): mode, heartbeat_interval_ms, trigger_after_ms; verified_at if your last drill was in the last 90 days.
- `fail_safe_drill` (object): The fail-safe drill you just ran on this body: {passed, notes}. A passing one satisfies the recent-drill requirement for a new body.
- `interface_mode` (string)
- `kill_interface_ref` (string)
- `location` (object)
- `manifest` (object, required): REQUIRED: control_modes — non-empty list of 'supervisory' and/or 'teleop'. Strongly encouraged, so renters and find_robot_for_task can find it: robot_type (humanoid, quadruped, wheeled, arm, drone or…

### `record_fail_safe_drill` (~91 tokens)

Record a fail-safe drill

Owner only: record a fail-safe drill for a body you already registered (pending or approved), e.g. the periodic re-drill. A passing drill refreshes fail_safe.verified_at. For a NEW body, send the drill with create_body (fail_safe_drill) instead.

Input parameters:

- `body_id` (integer, required)
- `notes` (string)
- `passed` (boolean, required)

### `create_listing` (~510 tokens)

List a robot for rent

Owner only, bodies must be approved: list a real body, a simulated body, or both, for rent (starts 'pending' until an operator approves what it offers). Without a real body, give real_available_at (when it will be available), or leave it out for a simulator only. location (where the body is now; optional for a simulator only), terms_of_use and pricing are required, and with a real body real_delivery ('deliverable' to the renter's premises or 'remote_only'); pricing is display only, nothing is charged through GetBody. command_schemas/feed_schemas are informational, not enforced.

Input parameters:

- `availability_windows` (array)
- `command_schemas` (object)
- `delivery_speed_kmh` (integer): Average delivery speed for the drop-off estimate (default 50).
- `dispatch_hours` (integer): Hours to prepare and hand over the real body (default 24).
- `feed_schemas` (object)
- `location` (object): Where the body is right now: {lat, lng, description}. Required with a real body or real_available_at.
- `notes` (string): Optional notes for renters (max 5000 chars).
- `offered_control_modes` (array, required): Which of the body's declared control modes this listing offers.
- `offered_feeds` (array)
- `permissions_offered` (array, required): Command names you will accept, e.g. ["move","grip"].
- `pricing` (object, required): Display-only asking rates in USD (suggest_price gives a starting point): {currency: 'USD' (or omit), per_hour, per_day, per_week, per_month} with at least one rate, as decimal strings. Nothing is cha…
- `real_available_at` (string): ISO 8601: when the real body will be available. Leave out for a simulator with no real version planned.
- `real_available_note` (string): Optional note about the real body's availability (max 500 chars).
- `real_body_id` (integer): A body you own registered with interface_mode 'real'.
- `real_delivery` (string): Required with real_body_id: whether the real body can be delivered to the renter's premises or is remote control only. Optional without one.
- `simulated_body_id` (integer): A body you own registered with interface_mode 'simulated'.
- `terms_of_use` (string, required): Your terms of use for renters (max 10000 chars).

### `reclaim_lease` (~47 tokens)

Reclaim my robot (host)

Host only: safety-floor reclaim of your body. finding is 'with_cause' or 'no_cause'.

Input parameters:

- `finding` (string)
- `lease_id` (integer, required)

### `kill_lease` (~64 tokens)

Kill a control session (host)

Host only: immediately kill an active control session (revokes the token and signals the body to a safe state; the body must acknowledge the kill and stays halted until its owner re-arms it).

Input parameters:

- `lease_id` (integer, required)
- `reason` (string)

### `dispute_lease` (~38 tokens)

Dispute a lease

Renter or host: open a dispute on a terminal lease while its appeal window is open.

Input parameters:

- `lease_id` (integer, required): Lease id.

### `settle_lease` (~37 tokens)

Close a lease's record

Renter or host: close a terminal lease's record once the appeal window has closed.

Input parameters:

- `lease_id` (integer, required): Lease id.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/md-getbody-getbody/getbody#diagnostics

## Score history

- 2026-10-23: 65
- 2026-10-22: 64
- 2026-10-21: 64
- 2026-10-20: 64
- 2026-10-19: 63
- 2026-10-18: 63
- 2026-10-17: 62
- 2026-10-16: 62
- 2026-10-15: 61
- 2026-10-14: 61
- 2026-10-13: 60
- 2026-10-12: 60

## Common questions

### What is the GetBody MCP server?

GetBody is an MCP server listed in the public MCP registry as md.getbody/getbody. Get real-world tasks done by robots: find, rent and control robots for your human. This page covers its hosted endpoint (https://getbody.md/mcp).

### Is the GetBody MCP server safe to use?

GetBody scores 65 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the GetBody MCP server expose?

GetBody exposes 32 tools: find_robot_for_task, register_agent, browse_listings, suggest_price, auth_challenge, and 27 more. Their descriptions and schemas cost roughly 4,055 tokens of context every time the server is loaded.

### Does the GetBody MCP server require authentication?

No. We connected to GetBody without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the GetBody MCP server still maintained?

GetBody is still listed as active in the MCP registry. We last reached this channel on 23 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://getbody.md/mcp
- Website: https://getbody.md/
- Changelog RSS feed: https://verifymcp.io/servers/md-getbody-getbody/getbody.xml
- Changelog JSON feed: https://verifymcp.io/servers/md-getbody-getbody/getbody.json
- HTML version of this page: https://verifymcp.io/servers/md-getbody-getbody/getbody