Neblla MCP

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, app shapes that fit, Neblla à la carte, and what it connects to. Then core (the default) — the can

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 play.neblla.com/<slug or id> (or the app's own domain); it serves the app once neblla_promote has se

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-pend

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 their own — accounts that work across all of their apps, saved per-user data, payments, content their u

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 accept (in the panel, «Compartido contigo»). On a shared app, use the tools its paper allows; the re

No parameter schema on file.

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, in as many words. Before you do: get their code out (neblla_versions migrate, or neblla_git) and re

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://localhost, https://localhost, null…) without a domain, and its new guests are limited per address.

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, moderation record, and stats: favorites, rating, reviews, uses, upvotes, downvotes, score); fetch a

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 votes do not count). Who voted is not shown.

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 the same rules as neblla.community.publish: community must be enabled, contentType/category must be

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 keep a community fed from elsewhere in sync.

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 author can answer from the SDK too (community.reply).

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 for breaking the rules, use neblla_moderate_community_entry (remove) instead.

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, remove and suspend require a reason from the fixed taxonomy; the author receives the reason and

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) — open cases first, since those are the ones needing a human; "get" (caseId) — the full claim; "close" (c

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. Tokens the developer deleted are not put back: they come back in missing. Stores the theme on th

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, ${...} or newlines; send the source verbatim. For binary files (images, fonts, audio, video) you have

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.

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 of the app's pre (what is being edited), including for apps

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: true to change every place it appears. The edits apply in order, each on the result of the ones befo

Delete a single file from an app (in an app linked to its own repo, a commit on pre's branch that drops it).

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.

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.

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). name should be a multi-language object e.g. { en: "Gold Coins", es: "Monedas de Oro" }. price (on

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.

List all products for a Neblla app.

Permanently delete a product from a Neblla 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), "singleplayer" (games/tools for one person at a time), or "app" (everything else — utilities, tools, site

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.

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 supp

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 as after until it is null. The cross-app Neblla account id is not included — only the per-app `_id

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.

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.

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.

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 wo

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.

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.

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.

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_get_user, modify, and write it back — and be aware the user may be saving at the same moment. Use spa

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 while they are away) and how many users are in each one right now.

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.

Delete (soft) one chat message from a room, as the developer. Users see it removed.

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 applies.

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 developer first.

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.

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 see it).

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?, detail?, at }. on says whether the app keeps the log; it is off by default (neblla_update_app moderati

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 pre with its own data, it names a moderator of pre (the developer adds themselves to moderate there);

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" (can play, and can still REPORT entries, but cannot publish, rate or review). Takes effect live. WA

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. An added flag reaches the developer's flag webhook with by: "developer". Returns the user's flag

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.

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 did not receive something — it would take away what little they have. Atomic: fails with insufficient_

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.

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 delete), and purchases are kept as payment records. Irreversible: pass confirm: true, and only when t

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.

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.

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.

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, community, ai…), every URL it answers at (by id and slug on each Neblla host and its Cloudflare de

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 least 5 characters. Changing it changes the public URL — confirm with the developer.

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 are never copied. Overwrites those settings on the target — confirm first.

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, the back office screens. Lines { id, at, by (an email), who: owner | team | moderator, access? (the

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: cards { activeToday, activeYesterday, activeThisWeek, activeLastWeek, weekTrend (% vs the week before),

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 added/changed/removed, settings that differ; differs:false means pro already matches; promotedAt is wh

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 a pass for 4 hours even if they sign out, so they can play as a guest; removing someone stops new p

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 with users. Changing it signs out whoever is signed in to pre. Without "use", returns the current one.

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 them, not even when pre plays with pro's data (neblla_pre_data), and there they give no credits. With

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 activity for 30 days; apps with an active subscription are exempt.

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 history is that repo's pre and pro branches, read and written with the developer's token, and a restore

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 push to it changes nothing for the users). One nuance worth getting right: while linked, every file

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 back. Actions: "status" (current engine + migration progress: progress {phase, processed, total, lef

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 they verify identity and add a bank account (a human must do it; never ask for bank details or documen

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 business address ({ country, postal_code, city, line1, state? }). "set_defaults": the default product

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 Stripe confirms it, so tell them the upgrade lands a few seconds after they finish. "cancel_pro" stop

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 name on all their apps.

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 primary address: when neblla_developer_profile says stripeEmailDiffers, ASK the developer first ("

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 shows everything else); on a change, leave value out to keep it. From th

The app's API secrets: name, baseUrl, headers, query, limits and fromClient. Never the values.

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.

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 app>). The URL carries a token shown only now; making it again with the same name gives a new token

The app’s incoming webhooks: name, to, room. Never their tokens (make one again for a new URL).

Delete an incoming webhook; its URL answers hook_not_found from then on.

Delete an API secret; the app's calls to it answer secret_not_found from then on.

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; { every: minutes } (5 – 10080); or { daily: "HH:MM", days?: [0–6, 0 = Sunday], tz?: "Europe/Madrid

The app’s automations with their schedule, action, next run and the result of the last one.

Run an automation now, to try it (its schedule does not change).

Delete an automation.

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: majority | odd | missing | undecided), diff (only the paths that differ), flagged. Undecided: no majo

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 per case.

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 one-use token valid one minute, and the front calls neblla.auth.login({ token }). action "create" mak

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" makes the key (refused if one exists), "rotate" replaces it (the old one stops at once), "status" says

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 it sealed, switches the app to "own" and deploys the box — the same room.js runner as Neblla’s cloud

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|production), certs? (the app signing SHA-256 from Play Console → App integrity: the app then opens f

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, updatedAt.

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.

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" { group, user, role } (user: the user id in the app, as neblla_list_users gives it; adding again changes t

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 } → { best, bestAt, dayBest, runs, place } or null; action "remove": take a user's score off a board

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? } → { trades, total }; each trade has from, to, give, get (items { table, id } or { product, amount }),

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" = last Friday), byMonthDay? (15, -1 = last day), byMonth?, until? (a date: that whole day) or count?, exc

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 } } } } }).

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: "$tomorrow" } } (dates: $now, $today, $tomorrow, $weekStart, $monthStart, $nextMonthStart), filters: [{ f

See a panel as the back office shows it: { appId, name, inputs? } → { title, columns, filters, actions, rows }.

The developer’s team for an app (Gente › Tu equipo in the panel): people who sign in to developers.neblla.com with their own email, and use this MCP with their own account, each with a paper (access) that the server applies on every route of the panel and every tool here: "partner" (Socio: everything but money, the plan and deleting the app), "support" (Comunidad y soporte: the people of the app

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 entries, the community put on hold by Neblla, data erasure requests, reviews without an answer, a "Pa

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, usesProData, the last restore; days: [{ date, createdAt, pro, pre }] with how many rows of each kind the copy

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 daily quota, like any message (msgFixedOut + the bytes of message and data, kind newCommunication). a

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, email and buyerName, canRefund. "documents" { saleId } — the links Stripe keeps for the buyer: a paymen

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 (source "client": client.js or another of its files; an uncaught promise too) or in a server file's hand

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 theirs as neblla_delete_app does (users, saves, purchases, subscriptions, domains) and their Neblla bill

No parameter schema on file.