# Neblla (remote · neblla.com)

Build and publish multiplayer apps and games on Neblla: scaffold, edit files, ship to the gallery.

- Trust score: 75/100 (medium)
- Change this week: +9
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

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

## Channel facts

- Endpoint: `https://neblla.com/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-08-03.

- **Endpoint Security**: 89/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation is enforced on tool calls, advertised via RFC 9728 protected-resource metadata. Discovery is public, which costs nothing: no tool can be invoked without a token.
  - 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.
  - The authorisation server offers only Dynamic Client Registration (RFC 7591), which MCP 2026-07-28 deprecated in favour of Client ID Metadata Documents.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 52/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 5602 tokens (~200/item across 28 items; 28 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 95/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 86% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http com-neblla-neblla https://neblla.com/mcp
```

### Codex

```toml
[mcp_servers.com-neblla-neblla]
url = "https://neblla.com/mcp"
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add com-neblla-neblla --url https://neblla.com/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-neblla-neblla:
    url: "https://neblla.com/mcp"
```

### Other

```json
{
  "mcpServers": {
    "com-neblla-neblla": {
      "type": "http",
      "url": "https://neblla.com/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-08-03 (score 75, +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-08-01 (score 74, +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-07-31 (score 73, +6)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 67, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-29 (score 67, +1)

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

### 2026-07-27 (score 66, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 65)

First indexed and scored.

## MCP tools (28)

### `neblla_get_llms` (~443 tokens)

Fetch the Neblla developer guide (llms.txt), split by topic so you read only what the app uses. Call this BEFORE designing or writing any code for a Neblla app — at minimum the `core` section (the default): the canonical six-file structure, the events-only client/server contract, and the five app patterns. Then fetch the sections matching the features you enabled: salas (rooms, lobby, matchmaking), servidor (the 3 server modes, setState, anti-cheat), identidad (login/SSO/scopes/save), social (friends + dev↔user communications), pagos (products/Stripe), ia (neblla.ai routes), publicar (gallery + quota table), referencia (the full API/events tables), mcp (this server's tools + creation flow), index (the table of contents), full (everything at once). Skipping core risks producing incorrect Neblla apps.

Each response lists the available `sections`. Most sections fit in one response; for long ones check `hasMore` and re-call with `offset` = `nextOffset`, concatenating chunks in order.

STALENESS CHECK — you connected to Neblla build 36. Each response carries the LIVE `latestBuild`. If `latestBuild` is greater than 36 (the build noted here), the server was redeployed AFTER you connected, so your loaded Neblla tool list is STALE. In that case, tell the developer plainly: "⚠️ The Neblla MCP updated to build <latestBuild> since this session started (you are on build 36). Restart/reconnect Claude Code to get the latest tools."

Input parameters:

- `maxLength` (integer): Maximum length of `guide` to return in this chunk. The default stays under the response-size limit of MCP clients.
- `offset` (integer): Character position to start reading from. 0 = start. Pass the previous response's `nextOffset` for the next chunk.
- `section` (string): Which part of the guide to read. Default "core" — the mandatory contract. "index" = table of contents, "full" = the whole guide.

### `neblla_get_app_url` (~101 tokens)

Returns the canonical public URL for a Neblla app in the gallery. ALWAYS call this after neblla_create_app — never construct the URL yourself. Apps are published and browsed at play.neblla.com. The URL format is https://play.neblla.com/<slug>, where <slug> is auto-generated from the app name at creation time and can be renamed in the dashboard.

Input parameters:

- `appId` (string, required): The app public ID

### `neblla_validate_requirements` (~505 tokens)

Walk the SAME decision map the Neblla dashboard wizard uses, before creating an app. STRONGLY RECOMMENDED before neblla_create_app on any new-app request (skip it only for edits/fixes to existing code). It front-loads every structural decision so the app is born configured right. 

How to use it: pass the `decisions` you can already answer from the user's request. The tool returns every still-pending decision, each with `how_to_infer` (how to answer it YOURSELF from context) and `ask_user` (whether it deserves a question to the human). The contract: ANSWER EVERY DECISION YOU CAN YOURSELF — only surface the ones in `ask_user_questions` to the user, and only when you genuinely cannot infer them; ask them all in ONE message. Then call this tool again with the full set. When `have_enough_context` is true, pass the returned `decisions` straight to neblla_create_app({ name, decisions }) — it scaffolds the matching pattern + themed UI pieces and writes the app config in one go. `plan` previews exactly what that will build. 

Decision ids: kind (game|app), players (single|lobby-only|multi — single = one device; lobby-only = everyone in one shared space with no separate rooms; multi = separate rooms), structure (turn-based|host-controllers|collab-realtime; multi only), login/friends/purchases/ai/communications (booleans — the feature pieces), connections (all|p2p|server), serverMode (js|wasm), roomsPolicy (ephemeral|public|private|mixed), matchmakingMode (nocode|custom), aiPayer (off|browser|server; when ai is on), palette ({primary, secondary, alert} hex colors — PICK THEM YOURSELF to match the app's character), typography (modern|editorial|techy|serif|playful — pick it yourself too).

Input parameters:

- `decisions` (object): Decisions answered so far, keyed by decision id. Example: { kind: "game", players: "multi", structure: "turn-based", login: true, palette: { primary: "#0F7BD7", secondary: "#15C2B0", alert: "#FF8552"…

### `neblla_create_app` (~600 tokens)

Create a new Neblla app. Returns the app ID (appId) to use in subsequent file upload operations. 

Recommended flow for a NEW app: 1) Call neblla_validate_requirements with the decisions you can infer from the request — it walks the same decision map as the dashboard wizard; answer what you can yourself, ask the user only what it flags, repeat until have_enough_context. 2) Call neblla_get_llms to read the SDK reference (the core section at minimum). 3) Call neblla_create_app (this tool) with the display name AND the validated `decisions` — that scaffolds the matching pattern with a themed UI piece per enabled feature (login, store, AI box, friends, inbox…) and writes the full app config, so you only EDIT files instead of writing from scratch. Omit `decisions` only if you genuinely want a blank app (just index.html). 4) Edit/replace the scaffolded files (or upload new ones). The server-side files live under server/ — index.html references only main.css and client.js (NEVER the server/ files — the SDK loads them); client.js wraps code in window.onNeblla; the server/ files are top-level code with no DOM access; client and server communicate only via events (tellServer / tellPresenter / sendMessage / setState / on('messageToServer'|'messageFromServer'|'message'|'state')). 5) Call neblla_get_app_url(appId) to get the correct public URL — NEVER construct it manually. Apps are served at play.neblla.com/<slug>, not under any /apps/ path.

Input parameters:

- `decisions` (object): The COMPLETE decision set from neblla_validate_requirements (have_enough_context: true → pass its `decisions` verbatim). Scaffolds the matching pattern with the themed UI pieces for each enabled feat…
- `name` (string, required): Display name for the app
- `serverMode` (string): Where the server/ files run: "js" (default — plain JS on a connected peer), "wasm" (AssemblyScript .ts → WASM on a peer, opaque to DevTools), or "infra" (JS on a Neblla worker per room — Beta — for r…
- `template` (string): Legacy alternative to `decisions`: scaffold the six canonical files wired to this pattern, with no feature pieces and no theme. Prefer `decisions`. Omit both for a blank app.

### `neblla_list_apps` (~19 tokens)

List all apps owned by the authenticated developer.

### `neblla_delete_app` (~32 tokens)

Permanently delete an app and all its files.

Input parameters:

- `appId` (string, required): The app public ID

### `neblla_update_app` (~425 tokens)

Update an app's configuration. Pass only the fields you want to change. Use addDomain/removeDomain to mutate the allowed-origins list atomically without overwriting other entries. `sandbox: true` lets the app load on localhost / non-https origins for development. `ai` is the AI proxy config for the SDK's neblla.ai() — set { model, maxOutputTokens, userTokenMode, presets, limitsEnabled, tokensPerDay } or null to disable. userTokenMode is one of: 'off' (server uses dev key only), 'browser' (user key, browser-direct), 'server' (user key, server-side with private preset prefixes). presets is a {name: prefix} map of named prompt prefixes invoked via neblla.ai({preset:'name'}). limitsEnabled + tokensPerDay cap how many Claude tokens each end-user can spend per day; only applied when userTokenMode = off. `inbox: true` enables the in-app communications inbox feature for end users.

Input parameters:

- `addDomain` (string): Append a domain entry (URL or origin) to the allowed list
- `ai`: AI proxy config: { model, maxOutputTokens, userTokenMode, presets, limitsEnabled, tokensPerDay } — pass null to disable
- `appId` (string, required): The app public ID
- `inbox` (boolean): Enable/disable in-app communications inbox for end users
- `matchmaking`: No-code matchmaking config: { mode: "nocode"|"custom", rule: "count"|"timer"|"count_then_timer"|"button", minPlayers, maxPlayers (0=unlimited), waitSeconds, allowPresenterStart }. In "nocode" mode th…
- `name` (string): New display name
- `removeDomain` (string): Remove a domain entry exactly matching this string
- `sandbox` (boolean): Allow non-https / localhost loads for development

### `neblla_upload_file` (~645 tokens)

Upload or update a file for an app. Pass text files (HTML, CSS, JS, TS, JSON, SVG) as raw UTF-8 text with encoding="utf8" (the default) — do NOT base64-encode them, even if they contain quotes, backticks, ${...} or newlines; send the source verbatim. For binary files (images, fonts, audio, video) you have TWO options: (a) pass a public URL via `contentUrl` — Neblla downloads the bytes server-side (recommended: no need to spend tokens base64-encoding the file in this conversation), OR (b) pass a base64 string via `content` with encoding="base64". Always prefer `contentUrl` when you have one. Uploading the same path again overwrites the previous version. 

Canonical paths for a Neblla app are index.html, main.css, client.js (front-end) plus server/lobby.js, server/gathering.js, server/room.js (server-side). The server/ files are special: the SDK loads them itself and runs them in an isolated scope with no DOM access — never reference them from index.html, and never put DOM code or window.onNeblla in them (they must be top-level code where `neblla` is in scope as a global). client.js, by contrast, uses window.onNeblla = (neblla) => {…}. Communication between client.js and the server files is events-only (sendMessage / tellPresenter / tellServer / messageToServer / messageFromServer / setState / on('message')) — never direct function calls. All three server/ files run on the room's SERVER PEER (a device the SDK picks, never the presenter): server/lobby.js for the lobby (matchmaking); server/gathering.js while a non-lobby room is in 'gathering' state (decide when to call neblla.startRoom() to start the game); server/room.js post-startRoom (authoritative game logic — handle messageToServer, broadcast with sendMessage / setState).

Input parameters:

- `appId` (string, required): The app public ID
- `content` (string): File content. For text files: the raw source as-is (NOT base64). For binary files: a base64 string. Required UNLESS `contentUrl` is set.
- `contentUrl` (string): Public URL of the file to upload. Neblla downloads it server-side (no need to base64-encode in this conversation). Use this for any binary asset (images, fonts, audio, video) when you have a URL. Mut…
- `encoding` (string): Content encoding for `content`. Ignored when `contentUrl` is used. Use "utf8" for all text files (HTML/CSS/JS/TS/JSON/SVG); "base64" only for binary assets.
- `path` (string, required): File path within the app. Canonical: "index.html", "main.css", "client.js", "server.js". Subfolders allowed for assets.

### `neblla_list_files` (~44 tokens)

List all files staged for an app. Returns path, mimeType, size, and timestamps for each file.

Input parameters:

- `appId` (string, required): The app public ID

### `neblla_get_file` (~343 tokens)

Get the content of a specific file. Text files (HTML, CSS, JS, JSON, SVG, plain text) are ALWAYS returned as UTF-8 strings — never base64. Binary files (images, fonts, audio) are returned as base64. The response includes an `encoding` field ("utf8" or "base64") so you know how to interpret `content`. Always returns the real current source, including for apps you created or published in a previous session. Use this to resume editing an existing app across sessions.

Large files are returned in CHUNKS — `content` may be only PART of the file. After each call, check `hasMore`: if true, call this tool again with `offset` set to the returned `nextOffset`, then concatenate the chunks in order. Decode (for binary) or edit only the FULLY reassembled string. `totalLength` is the total length of `content` across all chunks; `length` is this chunk's length.

Input parameters:

- `appId` (string, required): The app public ID
- `maxLength` (integer): Maximum length of `content` to return in this chunk. The default (20000) stays comfortably under the response-size limit of MCP clients; lower it further if your client still truncates the reply.
- `offset` (integer): Where to start reading, in units of the returned `content` (characters for utf8 text, base64 characters for binary). 0 = start of file. Pass the previous response's `nextOffset` to get the next chunk.
- `path` (string, required): File path, e.g. "index.html"

### `neblla_delete_file` (~49 tokens)

Delete a single file from an app.

Input parameters:

- `appId` (string, required): The app public ID
- `path` (string, required): File path to delete, e.g. "old-page.html"

### `neblla_move_file` (~89 tokens)

Rename or move a file within an app. oldPath is the current path, newPath is the destination.

Input parameters:

- `appId` (string, required): The app public ID
- `newPath` (string, required): New file path, e.g. "new-name.html" or "subfolder/file.html"
- `oldPath` (string, required): Current file path, e.g. "old-name.html"

### `neblla_create_product` (~224 tokens)

Create a purchasable product for a Neblla app. type must be "one_time" (single purchase, fixed price) or "consumable" (quantity selector, price per unit). name should be a multi-language object e.g. { en: "Gold Coins", es: "Monedas de Oro" }. price (one_time) and pricePerUnit (consumable) are in cents (e.g. 499 = $4.99).

Input parameters:

- `appId` (string, required): The app public ID
- `image` (string): Product image URL
- `max` (number): Maximum quantity for consumable
- `min` (number): Minimum quantity for consumable
- `name` (required): Product name, string or { en: "...", es: "..." }
- `price` (number): Price in cents — required for one_time
- `pricePerUnit` (number): Price per unit in cents — required for consumable
- `step` (number): Quantity step for consumable selector
- `type` (string, required)

### `neblla_update_product` (~219 tokens)

Update an existing product. Pass only the fields to change. Use this to adjust price, rename, or republish a product without losing its productId — changing the id would break checkout flows already wired into the app.

Input parameters:

- `currency` (string): ISO 4217 code, e.g. "usd"
- `defaultLang` (string)
- `description`: Description, string or per-language object
- `image` (string): Product image URL
- `max` (number): Maximum quantity for consumable
- `min` (number): Minimum quantity for consumable
- `name`: Product name, string or { en: "...", es: "..." }
- `price` (number): Price in cents (one_time)
- `pricePerUnit` (number): Price per unit in cents (consumable)
- `productId` (string, required): The product ID returned by neblla_create_product
- `published` (boolean): Whether the product is buyable
- `step` (number): Quantity step for consumable selector

### `neblla_list_products` (~31 tokens)

List all products for a Neblla app.

Input parameters:

- `appId` (string, required): The app public ID

### `neblla_delete_product` (~38 tokens)

Permanently delete a product from a Neblla app.

Input parameters:

- `productId` (string, required): The product ID returned by neblla_create_product

### `neblla_publish_app` (~494 tokens)

Publish a Neblla app to the public gallery. BEFORE calling this tool you MUST follow these steps with the user: 1) Ask for the app title and a short description (1-3 sentences) in the user's language. 2) Ask for the gallery section: "multiplayer" (games/apps where users interact in real time), "singleplayer" (games/tools for one person at a time), or "app" (everything else — utilities, tools, sites). 3) Ask for tags that describe the app (e.g. "puzzle", "multiplayer", "drawing"). 4) Ask what devices the app is best suited for: "mobile", "desktop", or omit for both. 5) Ask if the user wants to upload a cover image — pass an http(s) URL, a data: URI, or raw base64 JPEG/PNG. It will be auto-scaled to 400x400. 6) Provide the title and description in at least the user's language. You SHOULD also translate into other supported languages (en, es, fr, de, it, pt, ja, ko, zh, ar) for wider reach, but only the original language is required. Set defaultLang to the language the user originally provided the content in. titles and descriptions MUST each contain at least one entry in the same language.

Input parameters:

- `appId` (string, required): The app public ID
- `bestOn` (string): Device the app is best suited for. Omit for both mobile and desktop.
- `defaultLang` (string)
- `descriptions` (object, required): Description per language code (max 500 chars each). At least one entry required.
- `portrait` (string): Cover image. Accepts an http(s) URL, a data: URI, or raw base64 (JPEG/PNG/GIF/BMP/TIFF). Auto-scaled to 400x400 JPEG, stored as portrait.jpg, and set as cover_image.
- `section` (string, required): Gallery section: "multiplayer" (real-time/social), "singleplayer" (one player at a time), or "app" (utilities/tools/sites)
- `tags` (array): Tags describing the app
- `titles` (object, required): Title per language code, e.g. { en: "My App", es: "Mi App" }. At least one entry required.

### `neblla_unpublish_app` (~56 tokens)

Remove an app from the public gallery. The app keeps its files and URL — only its public listing is hidden. Use neblla_publish_app to re-publish.

Input parameters:

- `appId` (string, required): The app public ID

### `neblla_list_users` (~180 tokens)

List end users of an app — the people who connected through the SDK, NOT the developer's own account. Use this as the entry point for the backoffice flow: it returns a paginated list with each user's mongo `_id` (needed for every other backoffice tool), email, name, language, and stats. Pass `withCommunicationsOnly: true` to get only users who have communication threads — useful when triaging support.

Input parameters:

- `appId` (string, required): The app public ID
- `emailFilter` (string): Substring match against the user's email (case-insensitive). Ignored if withCommunicationsOnly is true.
- `limit` (integer)
- `skip` (integer)
- `sort` (string)
- `withCommunicationsOnly` (boolean): Only return users with a non-empty communications array

### `neblla_search_users_by_email` (~104 tokens)

Find users of an app by a partial email match (min 2 characters). Returns the matching user docs with email, communications, data, stats, and language. Use neblla_list_users for full pagination instead when no email is known.

Input parameters:

- `appId` (string, required): The app public ID
- `emailPart` (string, required): At least 2 characters of the email to match
- `limit` (integer)
- `skip` (integer)

### `neblla_get_user` (~93 tokens)

Fetch the full record of a single end user — their saved data, public info, purchases, and communications thread. Use the `_id` from neblla_list_users / neblla_search_users_by_email as `userId`.

Input parameters:

- `appId` (string, required): The app public ID
- `userId` (string, required): The user's mongo ObjectId hex string (the `_id` returned by neblla_list_users)

### `neblla_list_communications` (~173 tokens)

List communications across ALL users of an app, filtered and sorted. The most useful tool for triaging an inbox: show only unread, only messages from users (not the dev), only flagged-important, or only those mentioning a given email. Returns flat items with userId so you can follow up via neblla_send_communication on each thread.

Input parameters:

- `appId` (string, required): The app public ID
- `emailFilter` (string): Case-insensitive email substring filter
- `fromFilter` (string): "user" = sent by end-user, "dev" = sent by you, "all" = both
- `importantOnly` (boolean)
- `limit` (integer)
- `readFilter` (string)
- `skip` (integer)
- `sort` (string)

### `neblla_send_communication` (~213 tokens)

Send a message from the developer to a specific end user. The user receives it live via the SDK's `communicationUpdated` event if connected, and on next reconnect otherwise. Optionally attach a `data` JSON payload (rendered by the app), or a calendar/appointment proposal via dateFrom/dateTo. Set `thread` to the id of an earlier communication to group replies. BEFORE calling: confirm the message wording with the developer (you are speaking to their users on their behalf).

Input parameters:

- `appId` (string, required): The app public ID
- `data`: Optional JSON payload attached to the communication
- `dateFrom` (string): Optional calendar/appointment proposal start (ISO 8601)
- `dateTo` (string): Optional calendar/appointment proposal end (ISO 8601)
- `message` (string, required): Plain-text message body
- `thread` (string): Id of the parent communication to thread under
- `userId` (string, required): Target user's mongo ObjectId hex string

### `neblla_set_communication_read` (~98 tokens)

Mark a specific communication as read or unread (from the developer's side). The end user is notified live via a `communicationRead` socket event if connected.

Input parameters:

- `appId` (string, required): The app public ID
- `commId` (string, required): Communication id (the ISO timestamp returned when the message was created)
- `read` (boolean)
- `userId` (string, required): User's mongo ObjectId hex string

### `neblla_set_communication_important` (~96 tokens)

Toggle the "important" flag on a communication. This is dev-only metadata and is NOT broadcast to the end user — use it to bubble messages to the top of your own triage view.

Input parameters:

- `appId` (string, required): The app public ID
- `commId` (string, required): Communication id
- `important` (boolean)
- `userId` (string, required): User's mongo ObjectId hex string

### `neblla_delete_communication` (~81 tokens)

Permanently remove a communication from a user's thread. The end user is notified via a `communicationDeleted` socket event so their UI updates in real time.

Input parameters:

- `appId` (string, required): The app public ID
- `commId` (string, required): Communication id to delete
- `userId` (string, required): User's mongo ObjectId hex string

### `neblla_update_user_data` (~171 tokens)

Replace the `data` object for a specific end user (the same object the SDK's neblla.save() reads/writes). Use sparingly: this overwrites the user's saved state and the change is broadcast live. Useful for support (unstuck a player), moderation (clear a corrupted save), or admin tooling. If the app has a "bring your own database" target configured, this writes there. Mongo-reserved keys (starting with $ or containing ".") are rejected; total JSON size is capped at ~100KB and 10 levels deep.

Input parameters:

- `appId` (string, required): The app public ID
- `data` (object, required): The replacement data object (must be a plain object, not array/null)
- `userId` (string, required): User's mongo ObjectId hex string

### `neblla_delete_account` (~36 tokens)

For safety the MCP never deletes accounts directly. Returns a URL for the user to visit and confirm deletion from the Neblla dashboard.

## Diagnostics

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

## Score history

- 2026-08-03: 75
- 2026-08-02: 74
- 2026-08-01: 74
- 2026-07-31: 73
- 2026-07-30: 67
- 2026-07-29: 67
- 2026-07-28: 66
- 2026-07-27: 66
- 2026-07-26: 65

## Links

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