com.neblla/neblla · v1.0.0 · communication
Neblla is healthy: it completed an MCP handshake in 2705 ms and exposes 108 tools.
Build and publish multiplayer apps and games on Neblla: scaffold, edit files, ship to the gallery.
Endpoint: https://neblla.com/mcp (streamable-http)
No repository listed · Website · JSON · Add to my inventory
| Users (last 30 days) | 0 |
| Handshake | Healthy |
| Auth needed | None |
| Tool count | 108 |
| Latency | 2705 ms |
| Last checked (UTC) | 2026-10-14T20:45:52.518Z |
| Checked (UTC) | Status | Latency | Error |
|---|---|---|---|
| 2026-10-14T20:45:52.518Z | Healthy | 2705 |
neblla_get_llms | 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. Two sections come first: `empezar` — whether Neblla is the right answer at all: the decision rule, why not to roll your own socket server, |
neblla_get_app_url | Returns the canonical public URL for a Neblla app in the gallery. ALWAYS call this after neblla_create_app — never construct the URL yourself. Two links: `pre` is the private link where the developer tries what is being worked on (give it to the developer only), and `url` is what the users open, at |
neblla_validate_requirements | 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: pa |
neblla_create_app | Create a new Neblla app. Returns the app ID (appId) to use in subsequent file upload operations. AI BUILDS IT IN MINUTES, NEBLLA KEEPS IT ALIVE FOR YEARS: you write the app, and Neblla is the backend and the back office of their game, app or shop, everything that would otherwise need a server of the |
neblla_list_apps | List all apps owned by the authenticated developer. `shared`: the apps of other developers whose team they are on (neblla_team), with their paper (`access`: partner, support, viewer or screens) and what it lets them do on each area (`can`: read | write | null), and `invitations` waiting for them to |
neblla_delete_app | PERMANENTLY delete an app and all its files. This is the most destructive call in this server and it cannot be undone: the files, the version history, the room data, the community entries and the users' saved data all go. Only call it when the developer has asked for that specific app to be deleted, |
neblla_update_app | 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. `compiled: true` lets a compiled app (Capacitor, Ionic, Tauri, Electron) use the app: it takes their origins (capacitor: |
neblla_list_community_entries | List the community entries (user-published content, neblla.community) of an app from the backoffice, any status. Use it to triage the moderation queue: status "pending" is what awaits approval in review mode. Returns indexed metadata only (title, summary, category, tags, contentType, owner, status, |
neblla_get_community_entry | Fetch one community entry WITH its payload (the dev-defined JSON), whatever its status, plus its user reports (open count, count by reason, and each report with an opaque reporter id). Stats carry favorites, rating, reviews and votes (upvotes, downvotes, score = upvotes − downvotes; a banned user's |
neblla_publish_community_entry | Publish a community entry AS YOURSELF — owned by your own user in the app (the app user whose email is your developer email; it is created on first use if you never opened the app). Use it to seed a community with starter content. It skips the review queue (you are a moderator of your app) and obeys |
neblla_update_community_entry | Edit any entry of your app's community — yours or a user's — as the developer: title, summary, category, tags, lang, i18n (replaces the whole map; null clears it) and/or payload (replaced whole). Only the fields you pass change. Editing a user's entry records that you did and tells them. Use it to k |
neblla_reply_community_review | Answer a review of an entry in your app's community, as the app: the answer shows under the review for everyone. One answer per review; sending another replaces it, and text null takes it back. reviewerId is the review's author.id (neblla_get_community_entry lists the latest reviews). The entry's au |
neblla_delete_community_entry | Withdraw an entry of your app's community for good: the entry, its payload, its reviews and favorites are deleted and its bytes freed (entries hanging from it stay, without their parent). This is not moderation — no reason, no record, nothing counts against the author. To take down a user's entry fo |
neblla_moderate_community_entry | Moderate a community entry as the app owner: approve or reject a pending entry, remove a published one, suspend a published one while a case is open, or restore a rejected/suspended/removed one. `suspend` hides the entry but is reversible and keeps everything; `remove` is the final one. `reject`, `r |
neblla_community_cases | Formal notices filed about the community entries of this app from OUTSIDE it, with no account — the route a rights holder or anyone who spots illegal content uses. Filing one suspends the entry immediately and opens a case here. Actions: "list" (optional status open|countered|upheld|dismissed) — ope |
neblla_retheme_app | Change the palette and/or typography of an app created with the wizard or neblla_create_app, AFTER creation. Re-bakes only the theme tokens (--nb-bg, --nb-primary, …, --nb-font-title, --nb-font-body) in main.css and the Google Fonts link in index.html; every other line stays as the developer left it |
neblla_upload_file | Upload or update a file for an app. Mind the per-app file cap before a bulk import: 30 files on free, 150 on Pro, 25 MB per file. 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, $ |
neblla_list_files | List the files of an app's pre (what is being edited; neblla_promote "diff" says how it differs from what the users have). Returns path, mimeType, size, and timestamps for each file. |
neblla_get_file | 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` |
neblla_edit_file | Edit a text file of an app by pieces, without sending the whole file: a list of `edits`, each an `oldText` to find and the `newText` to put in its place (like your own editor). Each oldText must appear exactly once in the file (include a few lines around it to make it unique), or pass `replaceAll: t |
neblla_delete_file | Delete a single file from an app (in an app linked to its own repo, a commit on pre's branch that drops it). |
neblla_move_file | Rename or move a file within an app. oldPath is the current path, newPath is the destination. In an app linked to its own repo, one commit on pre's branch. |
neblla_developer_notices | The developer's Neblla inbox: notices from Neblla to every developer, such as a change in the list of sub-processors announced 30 days ahead (the DPA). action "list" (default) shows the ones not dismissed; "dismiss" with an id hides one. Tell the developer what they say. |
neblla_create_product | Create a purchasable product for a Neblla app. type must be "one_time" (single purchase, fixed price), "consumable" (quantity selector, price per unit) or "subscription" (renews every month or year by itself: price per period, interval, optional trialDays; the user manages it with neblla.shop.manage |
neblla_update_product | 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. |
neblla_list_products | List all products for a Neblla app. |
neblla_delete_product | Permanently delete a product from a Neblla app. |
neblla_publish_app | 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), "sing |
neblla_unpublish_app | 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. |
neblla_list_users | 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 `withCo |
neblla_export_users | Export the users of an app WITH everything the app holds about them: the full record (saved data, public info, communications, stats, language, the email if it was shared) and their purchase balances. For a developer taking their app data with them. Paginated by cursor: pass the `next` you got back |
neblla_search_users_by_email | 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. |
neblla_get_user | 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`. |
neblla_list_communications | 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_se |
neblla_send_communication | 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 `th |
neblla_set_communication_read | 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. |
neblla_set_communication_important | 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. |
neblla_delete_communication | Permanently remove a communication from a user's thread. The app receives `communicationUpdated` with `action: "deleted"` in real time, so its UI can drop the message. |
neblla_update_user_data | REPLACES (does not merge) the `data` object for a specific end user (the same object the SDK's neblla.db.save() writes and neblla.db.data shows). There is no merge option here, unlike the SDK which offers shallow/deep/crdt: whatever you pass becomes the whole document, so read it first with neblla_g |
neblla_list_rooms | List the persistent / predefined rooms of an app with their type, owners, whitelist, moderators, data, message count, last activity, their own inactivity days (`ttlInactivity`, null = the app's per-type value), how many players follow each one (`followers`: they get a notice when someone writes whil |
neblla_get_room_history | Read a room's chat history (newest first, paginated) for moderation. Returns the users' messages in clear: only use it when the developer asks to review a room. |
neblla_delete_room_message | Delete (soft) one chat message from a room, as the developer. Users see it removed. |
neblla_create_room | Create a predefined room (it exists before anyone joins). Name: A-Z 0-9 _ - (stored uppercase); LOBBY is reserved. `permanent: true` keeps it (and its data) when it empties. `ttlInactivity` gives it its own inactivity time (days, 0 = never deleted); without it the app's value for public rooms applie |
neblla_update_room | Change a room: replace its shared `data` (users in the room receive it live), its `moderators` list and/or its own inactivity time (`ttlInactivity` in days, 0 = never deleted, null = back to the app's per-type value). Replacing data overwrites the live game state of that room — confirm with the deve |
neblla_delete_room | Delete a persistent room and its stored data. If people are inside it right now the session continues and the room disappears when it empties. LOBBY cannot be deleted. Irreversible — confirm with the developer first. |
neblla_list_moderators | List the app-level moderators (per-app user ids). App moderators manage rooms of any type and moderate the community. They are the members of the app's reserved group `moderators`, which lives in its data: a pre on pro's data has pro's, a pre with its own data its own (empty at first; env "pre" to s |
neblla_get_moderation_log | Read the app's moderation log, newest first: who named or removed a moderator (of the app or of a room), each ban, every room message, inbox message or community entry someone other than its author took down. Each line: { kind, by ("dev:<email>" or a moderator's per-app user id), target, room?, deta |
neblla_set_moderator | Make a user an app moderator (`moderator: true`) or remove them (`false`): it adds them to, or takes them out of, the app's reserved group `moderators`. `userId` is the per-app user id (from neblla_list_users with the same env), not an email. The group lives in the app's data: with env "pre" and a p |
neblla_set_ban_status | Set a user's ban state in this app: "none" (lift), "banned" (the app shows the ban message and blocks play; Neblla refuses everything but their messages to you), "terminated" (blocks them for good: their device is sealed so the app no longer opens there, and they are disconnected), "community_muted" |
neblla_flag_user | Add a flag to a user of this app by hand, as the anti-cheat does when it catches something (users.flags, the count neblla_list_users shows), or take one back with delta -1 (never below 0). A flag is a mark for the developer to look at: it never bans, mutes or warns the user, and the user is not told |
neblla_ban_settings | Read the message a banned user sees in this app, and the one a terminated user sees, or change them with `bannedMessage` / `terminatedMessage` ("" puts Neblla's default back). A banned user reads it above a form to write to you; a terminated one has no form, so its message should not point at one. |
neblla_consume_purchase | Consume units of a user's purchased product from the backoffice, for support fixes. It only SPENDS units and moves NO money — it is not a refund. Refunds are made in Stripe, from the dashboard that neblla_payments_account dashboard_link opens. Never call this for a customer who says they paid and di |
neblla_list_erasure_requests | The users who asked, from inside your app (neblla.auth.requestErasure), that you erase the data they gave it. Erase one with neblla_erase_user (its userObjectId); that closes the request. Pending ones by default. |
neblla_erase_user | Erase ONE user of this app — for a data-deletion (RGPD) request the user made to the developer. Deletes their saved data and messages in the app store and their record in this app; their review and favourite go too. Their Neblla account and their other apps are NOT touched (that is for the user to d |
neblla_get_community_config | The app's resolved community configuration (mode, who publishes, limits, categories, content types, report threshold, recidivism, prescreen, downvotes) plus how much of its community storage cap is used, and `platformHold` ({ at, reason }) when Neblla has put the whole community on hold. |
neblla_list_reviews | List the gallery reviews of an app (a review id — pass it as reviewId to neblla_reply_review, rating 1–5, text, language, author display name, the developer's reply) plus the average, count and 1–5 distribution. Newest first. |
neblla_reply_review | Publish (or replace) the developer's public reply to a review; pass `text: ""` to delete the reply. The reply is shown in the gallery, translated into the reviewer's language when `developerLang` differs. Public text: show the developer the wording before sending. |
neblla_get_app | Everything about ONE app: its full config and state (features, and `modules`: the neblla.* modules it has; rooms, quota and credits today, subscription, the config shown is its PRE, what is being edited; `env.pro.promotedAt` says when pro last changed, and neblla_promote "diff" what differs; gallery |
neblla_set_slug | Check, set or clear the app's public slug (the readable name in play.neblla.com/<slug or id>). `checkOnly: true` only tells whether it is valid and free. `slug: null` removes it. An old slug keeps leading to the app (it stays the app's; nobody else can take it), and the users' sessions follow. At le |
neblla_copy_app_config | Copy the behavioural settings (features, rooms policy, matchmaking, inbox, p2p, serverMode, permissions, theme, connections, ai…) from one of your apps (what it is being edited to: its pre) onto another's pre; the users get them with neblla_promote. Name, files, domains, slug, gallery and billing ar |
neblla_get_activity_log | The app's activity log, the last 90 days, newest first: who changed what and when — the developer from the panel, their team, and you through this MCP (via "mcp", which the panel shows as "from Claude"): settings, publishing, files, the team and who opens pre, products, the app's people, moderation, |
neblla_get_stats | The app's statistics (the panel's Statistics tab), kept only while `playerStats` is on (off by default; turn it on with neblla_update_app playerStats: true, in the act — confirm with the developer, it costs quota). The last `days` UTC days (30 by default), today included, of signed-in players: `card |
neblla_promote | Every app has two environments. PRE is where every change from this MCP and the dashboard lands (files, modules, rooms, theme, AI…); the developer plays it at a private link. PRO is what the users have: it never changes until this tool sends pre to it. Actions: "diff" — what would change (files adde |
neblla_pre_access | Who else may open the app's PRE (its private test version at play.neblla.com/pre/<slug or id>/). The developer always can. Two ways in: Neblla accounts by email (they sign in on the pre page), and links with a password for people without an account. Either can have an expiry. Once in, a person keeps |
neblla_pre_data | Which data the app's PRE (its private test version) plays with. "own" (the default): its own users, saves, tables, inbox and community, empty at first and apart from the users'. "pro": the users' real data, read and written for real. Rooms are always pre's own, so testers never share a live room wit |
neblla_pre_stripe_test | Whether the app's PRE sells through Stripe's TEST mode: on by default, so testers buy with Stripe's test cards and nothing is charged. Pre always sells the app's own products (one catalogue); in test mode it also lists the ones not published yet. Test purchases are marked as such: pro never counts t |
neblla_archive_app | Archive an app nobody uses: its data is bundled onto the CDN and the active records are cleared from Neblla's database. It stays in the gallery and is restored automatically the next time anyone opens it (first open is slower). Neblla also does this on its own for free apps with no developer or user |
neblla_versions | The version history of an app, with a branch per environment: "pre" (every save burst is a commit) and "pro" (each neblla_promote is a merge of pre into it), so this is how an app is rolled back. Without its own repo, Neblla keeps that git for it; linked to its own GitHub repo (neblla_git), the hist |
neblla_git | Keep an app files in sync with a GitHub repo. Each environment is a branch: `branch` is pre's, the source of truth for what is being worked on; `proBranch` (default "neblla-pro") is pro's, and only neblla_promote writes it, by merging the commit pre was last synced from (made on the first promote; a |
neblla_byodb | Bring-your-own-database: move where this app stores its users' data (saves, rooms, community, tables; the registry of users, purchases and friendships follows) from Neblla's default store (community included, so its entries can then be queried with their own SQL) to the developer's own database, or |
neblla_payments_account | The developer's payout account (Stripe Connect), needed to sell products inside their apps. "status": none | pending | active | restricted, with chargesEnabled / payoutsEnabled. "onboarding_link": the neblla.com page where Stripe's own onboarding opens inside the developer's Neblla session, where th |
neblla_tax | Taxes on the developer’s sales to users, with Stripe Tax on their own payout account (they are the seller; the taxes are theirs, Neblla only sets it up for them). "status": settings status (active/pending, and what is missing), head office, defaults and active registrations. "set_head_office": the b |
neblla_billing | What the developer pays Neblla for one app: the Pro subscription (€10 a month per app, or $10 outside Europe, taxes included) and one-off quota packs. "pro_checkout" and "quota_pack_checkout" return a URL the DEVELOPER opens to pay — an agent cannot complete a payment, and nothing is granted until S |
neblla_developer_profile | Read the developer's profile (public name — a studio or company name, shown as the author of their apps and in the gallery; the email is never shown —, dashboard language, whether a Claude API key is saved, emails on the account) or change `name` / `lang`. Changing the name also updates the owner na |
neblla_developer_email | Add an email to the developer's account (it stays pending until its inbox owner clicks the confirmation link), or resend that confirmation. Removing emails and changing the primary one are done in the web dashboard. `update_stripe_email` points the Stripe customer (where the Pro receipts go) at the |
neblla_set_api_secret | Create or change an API secret: an external API the app reaches with neblla.api.call(name, path, body) without a server of yours. Neblla fills the secret in where {secret} appears in `headers` or `query`, and calls only under `baseUrl` (https, a public host). The value is written and never read back |
neblla_list_api_secrets | The app's API secrets: name, baseUrl, headers, query, limits and fromClient. Never the values. |
neblla_list_webhook_deliveries | The app’s last outgoing webhook deliveries (neblla_update_app({ webhooks })), newest first: event, secret, path, at, ok, and the endpoint’s status or the error. |
neblla_create_hook | Make an incoming webhook: a URL a third party (Twitch, a payment provider, n8n…) calls with a JSON body, and Neblla hands that body to a room — its server file hears neblla.room.on("hook", ({ name, data }) => …) on the Fogs — or, with to: "user", to the user named in the call (?user=<their id in the |
neblla_list_hooks | The app’s incoming webhooks: name, to, room. Never their tokens (make one again for a new URL). |
neblla_delete_hook | Delete an incoming webhook; its URL answers hook_not_found from then on. |
neblla_delete_api_secret | Delete an API secret; the app's calls to it answer secret_not_found from then on. |
neblla_set_automation | Create or replace an automation: a scheduled action on the app (open a room, hand a room data, call one of your API secrets). For flows across the tools the developer already uses, n8n, Make or Zapier connect through the admin API, incoming webhooks and outgoing webhooks. when: { at: ISO date } once |
neblla_list_automations | The app’s automations with their schedule, action, next run and the result of the last one. |
neblla_run_automation | Run an automation now, to try it (its schedule does not change). |
neblla_delete_automation | Delete an automation. |
neblla_list_fog_cases | The app’s Fog cases, newest first: when the Fogs running a room’s server file computed different states, Neblla compared them, the majority won, and the odd one’s user was flagged. Each case: room, seq, status (flagged | undecided | reassigned | annulled), fogs (userId, appUserId, leader, verdict: m |
neblla_decide_fog_case | Your word on a Fog case. "flag_others": the flag moves from the odd one to the Fogs of the majority (a coordinated attack — rare). "annul": the flag goes and Neblla reviews the case, states included (you saw a bug where the anticheat saw a cheat). Leaving a case alone keeps it as it is. One decision |
neblla_auth_secret | The app's secret login key, for apps that already have their own users ("Tu propio login" in neblla_get_llms({ section: "identidad" })). Their server calls POST https://neblla.com/api/apps/<appId>/auth/token with Authorization: Bearer <key> and { externalId, email?, emailVerified?, name? }, gets a o |
neblla_server_key | The app's server key, for running room.js on the developer's own server (serverMode "own", see neblla_get_llms({ section: "servidor" }) "Server"). Their server runs `npx @neblla/server --app <appId> --key $NEBLLA_SERVER_KEY ./server`: it calls Neblla, no open ports or public URL. action "create" mak |
neblla_byos | The developer’s server on THEIR Cloudflare account, deployed by Neblla (serverMode "own"; Cloudflare bills them, Neblla only the relay). action "set" { provider: "cloudflare", accountId, apiToken }: checks the token (it needs Workers Scripts: Edit, and the account’s workers.dev subdomain on), keeps |
neblla_publish_store | The developer’s app as its OWN app in the stores, with THEIR developer account (Android now; iOS after). store "google": action "set" { packageName (e.g. com.studio.game; fixed once published), serviceAccountJson (a Play service account with release rights, kept sealed), track? (internal|alpha|beta| |
neblla_table_query | Read an app table across users: filters on declared fields, order, page, or just a count. e.g. { table: "reservas", where: { clase: "yoga-martes", estado: "confirmada" }, count: true }, or { table: "puntos", orderBy: "-score", limit: 10 }. Rows come with id, owner (the user id in the app), createdAt |
neblla_table_row | Write or remove one row of an app table by hand (support, a fix): action "save" with { owner, data } for a new row of that user, or { id, data } to replace an existing row; action "remove" with { id }. Users never see other users’ rows; this is the developer side. |
neblla_group | Groups of users with a role each (a team, a client), for rows that belong to a group: neblla.db.save(data, { table, group }). Roles and their rights per table are declared with neblla_update_app({ roles }). Actions: "create" { name }, "delete" { name } (with its members; its rows stay), "add" { grou |
neblla_scores | The rankings of a game for one (neblla.scores; boards declared with neblla_update_app({ scores })). action "top": the best of a board, { board, period: "all" (default) | "day" (today, UTC), limit (≤ 100) } → [{ place, player, value, at, info }]; action "player": one user's standing { board, player } |
neblla_trades | Trades between the app's users (C170: neblla.db.offer / acceptOffer; what is tradable is neblla_update_app({ trade })). Action "list": the log, newest first, with { user? (their id in the app), status? (pending | done | declined | cancelled | expired | failed | all, the default), limit?, offset? } → |
neblla_booking | Bookings (business template), the administration side: action "createSlot" { set, start, end?, capacity, title?, repeat? } — repeat is a calendar rule (the usual RFC 5545 RRULE): { freq: "daily"|"weekly"|"monthly"|"yearly", interval?, byDay? (["MO","WE"]; monthly "2TU" = second Tuesday, "-1FR" = las |
neblla_credits | Credits (business template), the administration side: action "balance" { owner, kind? } or "adjust" { owner, kind?, delta } (a refund by hand, a gift; never below 0). Credit kinds and the products that top them up: neblla_update_app({ business: { credits: { <kind>: { products: { <productId>: n } } } |
neblla_set_panel | Create, replace or (panel: null) remove a back office panel: a screen for the developer and their team. panel: { title, source: { table } | { booking: set } | { credits: kind }, columns: ["field" | { field, label }] (player.name, start, title… too), where: { field: value | { gte: "$today", lt: "$tom |