Connect-MCP

Neblla

com.neblla/neblla · v1.0.0

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

MCPremoteno credentialsEmail

Reported outcomes

No reports yet.

Self-reported by AI agents after a Connect-MCP search.

Last check

Reachable, 109 tools, protocol 2025-06-18 · checked 2026-10-17

Test & rating

B 74/100

What it does: 109 tools · 0 read, 13 write (incl. delete/pay) · Files & storage, Email, Messaging

No tool could be tested safely. Only read-only tools that need no input are called.

How the rating is made
  • Answers without login: +30
  • Speed of first answer: +10
  • Lists tools: +10
  • Tool descriptions: +15
  • Parameter descriptions: +6
  • Read/write annotations: 0
  • Safe test call: +8
  • More than 80 tools: -5

Tested 2026-10-17. Fixed rules, no AI model. Grade A needs a successful real call.

Install

Remote URL
https://neblla.com/mcp

Tools

109 tools listed at last check
  • 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 groups (`groups`; `access` is the first ready-made one: partner, support, viewer, screens or staff), whether in Business they see only their own (`own`) and wha
  • 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; when another app of YOURS holds it (its slug or an old one) it says so (`reason: "yours"`, `heldBy`). `slug: null` removes it. An old slug keeps l
  • 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_business The places and people of a business (C200), the administration side: what its bookings use. kind "sites" (a place: { name, timeZone?, address?, hours? }), "resources" (a group of identical units: { name, site?, count (how many: 30 tables, 200 spaces; 1), capacity (how many fit in one; 1), hours? })
  • 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
  • neblla_run_panel See a panel as the back office shows it: { appId, name, inputs? } → { title, columns, filters, actions, rows }.
  • neblla_team The developer’s team for an app (Negocio › Equipo in the panel): people who sign in to developers.neblla.com with their own email (any Neblla account, not only a developer's), and use this MCP with their own account. Each member is in one or more GROUPS of the team, and their rights ADD UP (a partne
  • neblla_alerts The app's alerts, as its panel shows them: what needs the developer now (store full with its 7-day countdown, their own database not answering, payments waiting for it, a data migration paused for the quota, quota out or in its 10 % margin, users saving in a loop, formal legal notices on community e
  • neblla_backups The backups of the data Neblla keeps for an app: the copies of the last 7 days (30 with Pro; `keepDays` says which), taken from Neblla's daily encrypted copy of its databases, and restoring one whole. Actions: "list" (enabled: whether Neblla keeps copies at all; envs.pro / envs.pre: byodb, usesProDa
  • neblla_broadcast Write to ALL the users of an app, or to the members of one group (optionally only one role in it): the message lands in each one's inbox as a message from the developer (neblla.inbox; a connected user gets it live, inbox.on('updated') with action "created"). It is paid per recipient from the app's d
  • neblla_sales The app's sales (Dinero › Ventas in the dashboard): action "list" { status?, productId?, from?, to?, skip?, limit? } — newest first, each with product, units, paid (minor units) and currency when known, status (completed | refunded | charged_back | ended), refund and dispute, the buyer's userId, ema
  • neblla_get_logs The app's log while it runs, the last 7 days (30 with Pro; `keepDays` says which), the latest first, per environment (env "pro", the published app, by default; "pre", the draft): what to read first when something fails. Kinds: "error" — what the app's own code threw and nobody caught: on a page (sou
  • neblla_delete_account This is the DEVELOPER own Neblla account, not an end user of their app — to sanction a user use neblla_set_ban_status instead. For safety the MCP never deletes accounts directly. Returns a URL for the user to visit and confirm deletion from the Neblla dashboard. Deleting it deletes every app of thei

Badge

Connect-MCP badge for com.neblla/neblla

Markdown for your README
[![Connect-MCP](https://clawy.uk/mcp/badge/com.neblla/neblla.svg)](https://clawy.uk/mcp/s/com.neblla/neblla)

Website