Skip to main content
Glama
ProAbono MCP Installation

ProAbono MCP Installation

Official

ProAbono MCP Installation

npm Licence

A local MCP server that installs ProAbono into your site, from your IDE.

It gives your coding assistant the ProAbono documentation, the API Live contract and your own ProAbono configuration, so it can run the In-Site installation with you end to end, generate integration code already filled in with your real business identifier, Segment, offers and Features, read your account back to verify the result, and answer API questions from the real contract instead of guessing.

It runs locally, over stdio, against whatever account your credentials open. It has no environment concept of its own: your credentials are the only boundary.

Install

Claude Code

claude mcp add --transport stdio proabono --scope user -- npx -y @proabono/mcp-installation

VS Code

In .vscode/mcp.json:

{
  "servers": {
    "proabono": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@proabono/mcp-installation"]
    }
  }
}

Cursor

In .cursor/mcp.json (or ~/.cursor/mcp.json for every project):

{
  "mcpServers": {
    "proabono": {
      "command": "npx",
      "args": ["-y", "@proabono/mcp-installation"]
    }
  }
}

Requires Node.js 20 or later.

Related MCP server: pnlcs-mcp

Configuration

The server reads seven environment variables and nothing else. It refuses to start if any is missing, naming the ones it needs.

Variable

Holds

PROABONO_API_BASE

The API endpoint, https://api-{business_id}.proabono.com

PROABONO_BUSINESS_ID

Your numeric business identifier

PROABONO_SEGMENT_REF

The Segment your customers and offers belong to

PROABONO_AGENT_KEY

Basic auth username

PROABONO_API_KEY

Basic auth password

PROABONO_PORTAL_SECRET

HMAC key for the portal security hash

PROABONO_WEBHOOK_SECRET

Secret for the notification signature

All seven are in your ProAbono BackOffice, on one page: Integration → MCP. PROABONO_API_BASE must begin with https://, and PROABONO_BUSINESS_ID must be digits only.

Put them in the env block of your MCP client entry, in a file git ignores. That keeps each set of seven attached to one project and one ProAbono account — which is what you need once you have two sets, since sandbox and production are two accounts with different endpoints, identifiers and keys. Declare one entry per account, for example proabono-sandbox and proabono-production, each with its own env.

  • .vscode/mcp.json and .cursor/mcp.json sit inside your repository: add them to .gitignore before pasting a value into them. Cursor also reads ~/.cursor/mcp.json, outside every repository.

  • Claude Code: --scope user keeps the entry outside the repository. A project .mcp.json is normally committed, so write ${PROABONO_API_KEY} and the other six there instead of the values — Claude Code expands them from your environment.

  • VS Code can also prompt for a value through the inputs section of mcp.json, which keeps it out of the file.

  • Avoid shell exports: they hold one set per shell and per machine, and hand your production keys to every project you open.

  • The server does not read a .env file. It reads its process environment only.

No value you supply is ever logged, returned by a tool, put in an error message, or inlined into generated code. Generated code references the variable names.

First prompt

With the server added and the seven variables set, open your project and paste this into your assistant:

Help me install ProAbono in this project.

1. Call get_server_info to confirm the server is reachable, and tell me which version you are talking to.
2. Call installation_status to see whether an installation was already started here.
3. Run install_insite: tell me which stack you detected and why, check the prerequisites with me, then take me through the three In-Site steps and the notification endpoint in order, placing the generated code where my signed-in user is known.
4. List what I still have to do by hand in the ProAbono BackOffice.
5. When the code is in place, run verify_insite_installation and walk me through the go-live checklist.

Answer every question about the ProAbono API from search_documentation and get_api_reference, never from memory.

When it works, step 1 answers with the server version and a configuration whose status is complete, listing the seven variable names — never a value. If the ProAbono tools are not there at all, the server refused to start: a variable is missing, and the error naming it is in your MCP client's log. get_server_info never reports an incomplete configuration, because the server does not start on one.

The generators return code and edit none of your files; your assistant places it. The one file the server writes is .proabono/installation.json, the installation state: it carries no credential, is meant to be committed so a later session resumes where this one stopped, and is not written when a tool is called with record_state: false.

Point your keys at a Sandbox account to run this. verify_insite_installation makes sure the customer it verifies against exists — it creates one under an mcp-verify- reference when you name none — and the tools that usually come next — create_update_customer, create_subscription, the Usage writes, bill_customer — create real data in whatever account your credentials open.

Example prompts

Once the installation is under way, these are the questions a developer asks next. Your assistant picks the tools; the second column is the ones it usually reaches for.

You ask

Tools it usually triggers

"Which offers does my Segment expose, and which Features do they carry?"

list_offers, list_features

"Generate a pricing table over my real offers for this page, identified so a signed-in customer can subscribe in place."

generate_pricing_table

"Someone else started the ProAbono installation in this project. Where does it stand, and what is left in the BackOffice?"

installation_status

"Wire the notification endpoint into this app, and tell me how to activate it in the BackOffice."

scaffold_notification_endpoint

"Plan the portal lifecycle for me: upgrade, downgrade, dunning."

plan_integration

"Create a customer, subscribe them to my first offer, and show me their Usages."

create_update_customer, create_subscription, get_usages

"What would it cost this customer to go from 5 to 10 seats, and is it allowed?"

quote_usage_change

"Which endpoint lists a customer's invoices, and what does it return? Write the call in Go."

search_documentation, get_api_reference, generate_integration_code

What it covers today

The version you installed is in CHANGELOG.md, and get_server_info reports it:

  • The three In-Site steps, end to end: the Customer Portal embed with its security hash, the Subscription Workflow round trip, and the Usage synchronization with its cache, its gate and its resynchronization.

  • The notification endpoint, with signature verification, deduplication and the BackOffice procedure that activates it.

  • Verification: steps 2 and 3 exercised against your account, the go-live rules checked against your own files, and the twelve-item checklist.

  • Catalogue and account introspection: offers, Features, customers, subscriptions, Usages, invoices.

  • Writes across the lifecycle: customers and their settings, billing addresses, subscriptions and each of their four transitions, Usage writes for all three Feature types, balance lines and billing.

  • Documentation and API reference: natural-language search over the ProAbono corpus and the API Live contract.

Not in it, and planned: advanced In-Site options — CSS customization of the hosted pages, and further specific workflows.

Widget and plug-in installations (WordPress and similar) are out of scope by design: this server installs ProAbono In-Site, by code, whatever your stack would lend itself to.

Offers, Features, webhooks, pricing pages and the workflow redirect URL are configured in your ProAbono BackOffice, and the API cannot create them: the server reads them, names what is missing, and gives you the BackOffice path.

Tools

Writes marks a tool that changes data in the account your credentials open. It runs as soon as your assistant calls it, with no confirmation step: your credentials are the only boundary.

Documentation

Tool

What it does

Writes

search_documentation

Natural-language search across the ProAbono documentation and the API Live contract.

get_api_reference

Parameters and schema for a given endpoint or object.

Installation

Tool

What it does

Writes

install_insite

The whole In-Site installation, end to end: stack detection, the prerequisites gate, the three steps in order, and the progress recorded in .proabono/installation.json.

installation_status

Where the installation stands: what is done, what was generated where, what is pending in the BackOffice, what was skipped.

install_customer_portal

The Step 1 in-site embed, with the security hash, for your stack.

link_subscription_workflow

Step 2: the encrypted query read from Links, both ways of opening a workflow, and the single return route covering all five outcomes.

sync_usage_rights

The Step 3 rights module: the Usage read, the cache and its expiry, the gate, the write-back for a Feature your application changes, and the resynchronization.

scaffold_notification_endpoint

The webhook endpoint: signature verification, the validation handshake, deduplication, a fast acknowledgement, and the BackOffice procedure that activates it.

verify_insite_installation

Steps 2 and 3 exercised against your account — on the customer you name, created if missing, or on a new one — the go-live rules checked against your files, and the twelve-item checklist.

yes

Code generation

Tool

What it does

Writes

generate_pricing_table

A pricing table over your real offers.

plan_integration

The ordered plan for a journey: installation, subscription funnel, portal lifecycle, usage metering, notifications.

generate_integration_code

Code for a task in the language you name, from the contract and the documentation.

Catalogue

Tool

What it does

Writes

list_offers

The offers your Segment exposes.

list_offers_for_customer

The offers one customer may take, and the upgrade options of a running subscription.

get_offer

A single offer by reference.

list_features

The Features of your Business.

Customers

Tool

What it does

Writes

get_customer

A customer by reference.

create_update_customer

Create a customer, or update one that already carries the reference. One tool: the endpoint is an upsert.

yes

get_billing_address

The address invoices are issued against.

update_billing_address

Update that address, changing only the fields you supply.

yes

get_payment_settings

Payment type, billing mode, grey-list flag, invoice note and next billing date, in one read.

set_next_billing_date

Set the date of the customer's next billing.

yes

set_invoice_note

Set the note printed at the bottom of every upcoming invoice of the customer.

yes

set_payment_method

Record a manual payment method; Card and DirectDebit are driven by the payment gateway.

yes

anonymize_customer

Irreversible. The GDPR erasure path: it erases the personal data and keeps the invoices and the subscription history. ProAbono refuses it while the customer has an invoice due, and erases nothing.

yes

Subscriptions

Tool

What it does

Writes

get_subscription, list_subscriptions

What a customer is subscribed to.

create_subscription

Subscribe a customer to an offer.

yes

start_subscription

Start a draft subscription, or restart a suspended one.

yes

upgrade_subscription

Move a subscription to another offer.

yes

suspend_subscription

Suspend it; start_subscription reverses that.

yes

terminate_subscription

Terminate it, at the end of the term by default.

yes

Usage and rights

Tool

What it does

Writes

get_usages

A customer's current Usages, as ProAbono sees them.

quote_usage_change

Price an intended change, and check it is allowed, before applying it.

push_usage_increment

Report consumption of a Consumption Feature.

yes

push_usage_quantity

Set the provisioned quantity of a Limitation Feature.

yes

push_usage_enabling

Switch an OnOff Feature.

yes

Invoicing and balance

Tool

What it does

Writes

get_invoice

A debit invoice, with its PDF URL when it publishes one — an invoice read right after it is issued may not publish one yet.

get_credit_note

A credit note, with its TypeCredit, its reason and its PDF URL when it publishes one.

list_invoices

A customer's billing documents, both kinds together.

create_balance_line

A debit, or a credit when the amount is negative.

yes

bill_customer

Invoice whatever is sitting in the balance.

yes

Server

Tool

What it does

Writes

get_server_info

Version and configuration status, values excluded.

No tool in this server destroys billing history: deleting a customer, a subscription or an invoice is out of scope in any account, and ProAbono's customer-suspension, invalidation and link-revocation endpoints exist and are deliberately not exposed. anonymize_customer is the one tool whose effect cannot be undone, and it is not a destruction — it erases personal data and keeps the invoices and the subscription history, which is what a GDPR erasure asks of a billing system.

Troubleshooting

Symptom

Cause

Fix

The ProAbono tools do not appear in your assistant, and your MCP client's log says a configuration variable is missing

The server refused to start: a variable is missing or empty

Set every variable the message names in the env block of the entry, then restart the client

The log says PROABONO_API_BASE must be an https:// endpoint

The endpoint does not begin with https://

Use https://api-{business_id}.proabono.com, with your own business identifier

The log says PROABONO_BUSINESS_ID must be the numeric business identifier

The identifier holds something other than digits

Keep the digits only: no prefix, no quotes, no spaces

A tool answers ProAbono API error 401

The Agent key or the API key is wrong

Copy both again from your BackOffice

A tool answers ProAbono API error 401, and both keys are right

The endpoint and the keys come from two different accounts

Take all seven variables from the same account

Building from source

The published package is self-contained: the ProAbono API contract and documentation are copied into dist/resources/ at build time, so nothing is fetched at run time.

A clone builds the same way, with no credential and no access to anything of ours:

npm ci && npm run build && npm test

Both sources the build vendors live in this repository, under resources/: the API Live contract in resources/open-api/ and the documentation corpus in resources/docs/. The contract is a copy of the one ProAbono maintains internally. npm run build and npm test refresh it from there when that source is reachable, and use the committed copy when it is not — which is the case in CI and in any clone of this repository — and say which on every run. See resources/open-api/index.md.

Support

Issues and questions: mcp@proabono.com.

When reporting a problem, include the output of get_server_info — it reports the server version and which variables are configured, and never their values.

Beyond this server:

Licence

MIT. See LICENSE.

Available Tools

43 tools
anonymize_customerAnonymize a customer, irreversibly (write)A

WRITE, AND IRREVERSIBLE. Erases the personal data of a ProAbono customer -- name and email -- and keeps their invoices and their subscription history, which is what a GDPR erasure asks of a billing system. There is no de-anonymization: the Live API offers none, and the erased values cannot be recovered from ProAbono by any means. This is the only tool in this server whose effect cannot be undone. Use it to serve an erasure request, never to tidy up test data, and confirm with the developer that this is the customer they mean before calling it -- the reference is the only thing identifying them, and a typo anonymizes somebody else. ProAbono refuses the call while the customer still has a due invoice: settle or cancel what is outstanding first.

Inputs: customer_ref (required).

bill_customerInvoice a customer's balance (write)A

WRITE. Creates an invoice from the lines currently sitting in a ProAbono customer's balance, and returns it. Whatever is in the balance is what gets invoiced, so create_balance_line is what decides the amount and runs first -- billing an empty balance invoices nothing. The invoice is issued for real and, for a customer on an automated payment method, a charge is attempted immediately. Read it back afterwards with get_invoice, whose answer carries the PDF URL.

Inputs: customer_ref (required), note, period_end, period_start, +2 more.

create_balance_lineAdd a line to a customer's balance (write)A

WRITE. Creates a line in the balance of a ProAbono customer: a debit when the amount is positive, a credit when it is negative. The amount is in cents, in the Segment's currency. This does not invoice anything -- it puts an amount in the balance, waiting. bill_customer is what turns the balance into an invoice, and the pair is only useful in that order. Use it for a one-off charge or a goodwill credit that the catalogue does not cover.

Inputs: amount (required), customer_ref (required), date, label, +6 more.

create_subscriptionSubscribe a customer to an offer (write)A

WRITE. Creates a ProAbono subscription linking an existing customer to an offer. This is the API path; a customer choosing a plan themselves goes through a hosted subscription workflow instead. The subscription is created as a copy of the offer -- pass an override only where the merchant genuinely departs from their own catalogue. Set start_now to activate it immediately; a subscription left in Draft grants no rights. A draft one is activated later with start_subscription.

Inputs: offer_ref (required), customer_ref (required), bill_now, metadata, +3 more.

create_update_customerCreate or update a ProAbono customer (write)A

WRITE. Creates a ProAbono customer in the configured Segment, or updates it when one already carries that reference -- the endpoint is an upsert keyed on ReferenceCustomer, so this one tool covers both and never fails because the customer exists. Use it for the first provisioning at sign-up or first login, which is the recommended path (the hosted pages and the rights read both need the customer to exist), and for every later change. Only the fields passed are written. Do not pass a field the merchant's application is not the authority for: the hosted pages let customers edit their own name and language, and this overwrites what they set.

Inputs: customer_ref (required), name, email, language, +1 more.

generate_integration_codeGenerate ProAbono integration code for a task, in a given languageA

Generates code for a ProAbono task in the language you name, from the API Live contract and the installation documentation — no per-language SDK, because there is none. Returns the authenticated client (Basic auth read from configuration, the Segment carried, collections read to TotalItems, 204 handled), the operations the task actually needs with their real parameters read from the contract, and the guardrails the code has to satisfy. Use it for a task no task-specific generator covers; where one does — the portal, the pricing table, the workflow round trip, the rights cache, the webhook endpoint — it says so and names it, because those carry rules a generic generator cannot know.

Inputs: task (required), language (required).

generate_pricing_tableGenerate the ProAbono pricing table embedA

Generates the embed that renders the ProAbono pricing table inside a page of the merchant's site. Two flavours: anonymous for a public pricing page, or identified for a signed-in customer, who can then subscribe in place -- which needs the customer reference and the security hash. What happens when a plan is chosen is configured in the BackOffice, not in this code.

Inputs: stack (required), identified (required), target_page (required).

get_api_referenceLook up a ProAbono API Live endpoint or objectA

Returns the exact contract of a ProAbono API Live endpoint (parameters, whether each is required, request body schema, responses) or of a named object such as Customer, Subscription, Offer, Feature or Usage. Use it before calling or generating a call to the ProAbono API, so parameter names and shapes come from the contract rather than from memory.

Inputs: object, endpoint.

get_billing_addressRead a customer's billing addressA

Reads the full billing address of a ProAbono customer: company, name, both address lines, postcode, city, country, region, phone and tax identifier. Read-only. This is the address invoices are issued against, and the tax identifier is what the VAT treatment is derived from -- read it before deciding whether an update is needed.

Inputs: customer_ref (required).

get_credit_noteRetrieve a credit noteA

Retrieves one ProAbono credit note with all its detail: its TypeCredit -- Refund when a paid invoice was given back, Voiding when one was cancelled before payment -- the Reason it was issued for, its amounts and its PDF URL, taken from the document's own Links. Read-only. Identify it by internal identifier or by full number; pass one, not both. A credit note is an invoice carrying TypeCredit, and the Live API serves both kinds from the same endpoint: if the identifier names a debit invoice, this tool says so rather than returning it as a credit note. Use get_invoice for a debit invoice.

Inputs: invoice_id, full_number.

get_customerRetrieve one customerA

Retrieves a ProAbono customer by the reference shared with the merchant's application (ReferenceCustomer), with the Links its hosted pages are opened from. Read-only. Use it to check whether a logged-in user already exists as a ProAbono customer.

Inputs: customer_ref (required), offer_ref.

get_invoiceRetrieve a debit invoiceA

Retrieves one ProAbono debit invoice with all its detail -- status, amounts, dates, payment method, the note printed on it -- and its PDF URL, taken from the document's own Links. Read-only. Identify it by internal identifier or by full number; pass one, not both. A credit note is a different document: use get_credit_note for it. If the identifier turns out to name one, this tool says so rather than returning it as an invoice.

Inputs: invoice_id, full_number.

get_offerRetrieve one offerA

Retrieves a single ProAbono offer by its reference, with its Features, pricing and the Links it exposes. Read-only. Use it when the offer reference is already known.

Inputs: offer_ref (required), customer_ref.

get_payment_settingsRead a customer's payment settingsA

Reads the payment settings of a ProAbono customer in one call: the active payment type, the billing mode, whether the customer is grey-listed, the note printed on upcoming invoices, and the date of the next billing. Read-only. These are the settings that set_payment_method, set_invoice_note and set_next_billing_date each write one field of.

Inputs: customer_ref (required).

get_server_infoProAbono server infoA

Reports the version of the ProAbono MCP Installation server and confirms that its ProAbono configuration is complete. Returns variable names only -- never a key, a secret or an account identifier. Use it to check the server is reachable and configured before running an installation.

Inputs: no named parameters.

get_subscriptionRetrieve one subscriptionA

Retrieves one ProAbono subscription of a customer, with its state, its dates and the Features it carries. Read-only. The customer reference is required: the Live API has no retrieve-by-identifier operation for subscriptions, so a subscription is always reached through the customer who holds it. Pass subscription_id as well when the customer has several and a specific one is meant; without it, the customer's current subscription comes back. Use list_subscriptions to see them all.

Inputs: customer_ref (required), offer_ref, subscription_id.

get_usagesRead a customer's rightsA

Reads a customer's Usages: what that customer may do right now, as ProAbono sees it, one entry per Feature carried by their running subscriptions. Read-only. This is the source an application gates access on -- never the offer reference. An empty result is ambiguous: check the customer's subscriptions with list_subscriptions before concluding they have no rights.

Inputs: customer_ref (required), feature_ref.

installation_statusRead back where the ProAbono installation standsA

Reads .proabono/installation.json in the developer's project and reports where the In-Site installation stands: which steps are done, which were generated but not yet confirmed in place, which were deliberately skipped, what was generated where, and which BackOffice actions are still pending. Call it at the start of a session before generating anything, and whenever a developer asks what is left to do. A project that has never been installed is reported as such, which is an answer and not a failure.

Inputs: project_root.

install_customer_portalInstall the ProAbono Customer Portal in a pageA

Generates the code that embeds the ProAbono Customer Portal inside a page of the merchant's own site -- current plan, invoices, payment method, billing address, usage -- for the signed-in customer. This is step 1 of the In-Site installation. Returns the server-side security hash computation, the route that renders the page, and the snippet to place in the template. Requires an authenticated customer area: the hosted pages always render for an identified customer.

Inputs: stack (required), target_page (required), project_root, record_state, +1 more.

install_insiteInstall ProAbono in this site, end to end (In-Site orchestrator)A

Orchestrates the whole In-Site installation: detects the stack from the open project and states its hypothesis, settles the Segment, checks the four prerequisites before generating anything -- an authenticated customer area, a catalogue whose offers carry Features, how a ProAbono customer will exist for a signed-in user, and a page to host the portal -- then runs the three steps in order, Customer Portal, Subscription Workflow, rights synchronization, and records progress in .proabono/installation.json so a later session resumes instead of starting over. Call it when a developer asks to install, set up or integrate ProAbono. It installs ONE way, In-Site by code: it never offers a Widget or a plug-in, whatever the stack. It generates code and returns it; it writes no source file of yours.

Inputs: stack, target_page, project_root, provisioning, +3 more.

list_featuresList the Features defined on the businessA

Lists the ProAbono Features of the account: the definitions the business owns, each with its type (OnOff, Limitation or Consumption). Read-only. These are what an application can gate access on. A Feature is the definition; a customer's value for it is a Usage, read with get_usages. Reads every page.

Inputs: visible_only.

list_invoicesList a customer's billing documentsA

Lists the billing documents of a ProAbono customer: debit invoices and credit notes together, as the Live API returns them, with TypeCredit telling the two apart -- present means a credit note, absent means a debit invoice. Read-only. There is no kind filter, here or in the API: filter the returned list yourself if only one kind is wanted, and say so in the answer, because the count reported here is the customer's full document history. Reads every page.

Inputs: customer_ref, subscription_id.

list_offersList the offers of the accountA

Lists the ProAbono offers the configured Segment exposes, with the Features each one carries and its pricing. Read-only. This is the catalogue: what the merchant sells, to anyone. Use it to show a pricing page, to pick the offer a subscription or a pricing table targets, or to check the prerequisite that at least one offer exists and carries at least one Feature. For what one named customer may take, or what a running subscription can move to, use list_offers_for_customer instead. Reads every page, not just the first.

Inputs: visible_only.

list_offers_for_customerList the offers one customer may takeA

Lists the ProAbono offers a named customer may take right now, which is not the same set as the catalogue: it accounts for what they already hold. Read-only. Set upgrade_only, with the subscription's identifier when the customer holds several, to get the upgrade and downgrade options of a running subscription -- the answer to "what can this customer move to?", which list_offers cannot give. Use list_offers for the public catalogue. Reads every page.

Inputs: customer_ref (required), upgrade_only, visible_only, subscription_id.

list_subscriptionsList subscriptionsA

Lists ProAbono subscriptions, optionally those of one customer, with their state and the Features they carry. Read-only. Use it to see what a customer is actually subscribed to, or to explain why a customer has no rights. Reads every page.

Inputs: customer_ref.

plan_integrationPlan a ProAbono integration journey, step by stepA

Returns the ordered plan for a named journey — installing ProAbono In-Site, building a subscription funnel, letting a customer manage their plan, metering usage, or reacting to notifications — naming the tool that generates each step and what a human still owes in the BackOffice. It plans and executes nothing. For the In-Site installation it describes the same sequence install_insite runs, because both read one description of it. Call it when a developer asks what the steps are, what order they go in, or what they are in for, before any code is generated.

Inputs: journey (required).

push_usage_enablingEnable or disable an OnOff Feature (write)A

WRITE. Enables or disables an OnOff Feature in the active subscription of a customer -- an option they switch on or off. OnOff Features only; use push_usage_increment for a metered Feature and push_usage_quantity for a Limitation one. The value is absolute, so repeating the call is harmless. Note that what the application must then enforce is IsEnabled, not IsIncluded: a Feature included in the offer can still be switched off. Quote it first with quote_usage_change when enabling is billable.

Inputs: is_enabled (required), feature_ref (required), customer_ref (required), date_stamp, +1 more.

push_usage_incrementReport consumption of a metered Feature (write)A

WRITE. Adds an increment to the current quantity of a Consumption Feature of a customer -- the metered kind: messages sent, API calls made, gigabytes stored. Report what was just consumed, not a running total: the value is added to what ProAbono already holds. Consumption Features only; use push_usage_quantity for a Limitation Feature and push_usage_enabling for an OnOff one. A repeated call double-counts -- there is no absolute mode to fall back on for a metered event, so the caller is responsible for not sending the same consumption twice, including on a retry after a timeout. Quote it first with quote_usage_change when it is billable.

Inputs: increment (required), feature_ref (required), customer_ref (required), date_stamp, +1 more.

push_usage_quantitySet the quantity of a Limitation Feature (write)A

WRITE. Sets the current quantity of a Limitation Feature of a customer to an absolute value -- seats, projects, users. Send the quantity the application has provisioned, the seats bought and not the seats occupied: that is what ProAbono bills on. The value is absolute, so sending it twice is harmless, which is why this write takes no increment. Limitation Features only; use push_usage_increment for a metered Feature and push_usage_enabling for an OnOff one. Quote it first with quote_usage_change when it is billable.

Inputs: feature_ref (required), customer_ref (required), quantity_current (required), date_stamp, +1 more.

quote_usage_changePrice a Usage change before applying itA

Prices an intended Usage change without applying it, and checks that it is allowed: what the customer would be charged now, and, with next_term, what their recurring cost would become. Read-only -- nothing is written. Call it before push_usage_increment, push_usage_quantity or push_usage_enabling whenever the change is billable, and show the amount to the end customer for confirmation before the write. Pass exactly one of increment, quantity_current or is_enabled, matching the Feature's type.

Inputs: feature_ref (required), customer_ref (required), increment, next_term, +4 more.

scaffold_notification_endpointScaffold the ProAbono notification (webhook) endpointA

Generates the HTTP endpoint that receives ProAbono notifications: signature verification in constant time, the validation handshake ProAbono sends before a webhook goes live, deduplication on the notification id, a fast acknowledgement with the work done out of band, and the worker that runs one global rights resynchronization for the affected customer. Also returns the BackOffice procedure that creates and validates the webhook, which no API can perform. This is what makes the rights cache of sync_usage_rights correct rather than merely bounded by its maximum TTL. Writes the installation state unless record_state is false.

Inputs: stack (required), project_root, record_state, endpoint_path.

search_documentationSearch the ProAbono installation documentationA

Answers a natural-language question about integrating ProAbono from the official installation documentation: hosted pages, the security hash, subscription workflows, rights and usage, webhooks, testing and troubleshooting. Use it before writing any ProAbono integration code, and prefer it over recalling ProAbono behaviour. Returns the matching documentation sections with their source file.

Inputs: question (required), limit.

set_invoice_noteSet the note printed on a customer's invoices (write)A

WRITE. Sets the note printed at the bottom of every upcoming invoice of a ProAbono customer, and changes nothing else about their payment settings. Use it for a purchase order number, a cost centre, or anything the customer's own accounting needs on the document. It applies to invoices issued from now on, never to ones already issued.

Inputs: note (required), customer_ref (required).

set_next_billing_dateSet a customer's next billing date (write)A

WRITE. Sets the date of the next billing of a ProAbono customer, and changes nothing else about their payment settings. Use it to align a customer's billing on a date the merchant chose -- a common anniversary, or the end of a negotiated period. Read the current value with get_payment_settings first: moving the date forward skips a period rather than compressing it.

Inputs: customer_ref (required), date_next_billing (required).

set_payment_methodRecord a manual payment method for a customer (write)A

WRITE. Records the manual payment method a ProAbono customer settles their invoices with -- bank transfer, cash, cheque or other -- and changes nothing else about their payment settings. Manual methods only: Card and DirectDebit are driven by the payment gateway and the endpoint refuses them here, so a customer paying by card is set up through the Customer Portal instead, never through this tool.

Inputs: customer_ref (required), payment_method (required).

start_subscriptionStart or restart a subscription (write)A

WRITE. Activates a ProAbono subscription that is in Draft, and restarts one that was suspended -- it is the same transition, and this is the tool to reach for to unsuspend a subscription; there is no separate resume or unsuspend operation. A subscription grants no rights until it is started, so this is what turns a created subscription into usable access. Re-read the customer's rights afterwards with get_usages.

Inputs: subscription_id (required), bill_now, ensure_billable.

suspend_subscriptionSuspend a subscription (write)A

WRITE. Suspends a ProAbono subscription. A suspended subscription stops granting rights and stops being billed, and is not terminated: start_subscription restarts it, which is the difference from terminate_subscription. Re-read the customer's rights with get_usages afterwards.

Inputs: subscription_id (required).

sync_usage_rightsGenerate the rights synchronization (In-Site step 3)A

Generates the code that reads a customer's rights from the ProAbono Usage API, caches them correctly and gates access on them -- step 3 of the In-Site installation, and the one that decides what a signed-in user may actually do. Returns the rights module for the stack, the gate at a call site, the write-back for a Feature the application changes (quoted and confirmed with the end customer when it is billable), and the cache expiry policy. Reads the account's real Features so the code names them. Give customer_ref to also diagnose what that customer's Usages currently say, which is how an empty response is told apart from a broken integration. Never gate on the offer reference: rights come from the Usage API.

Inputs: stack (required), customer_ref, feature_refs, project_root, +1 more.

terminate_subscriptionTerminate a subscription (write)A

WRITE. Terminates a ProAbono subscription. By default it takes effect at the end of the current term, so it is not an immediate loss of access: the customer keeps their rights until then, and an application that revokes access on the call is wrong. Set immediate to end it now, or termination_date to schedule it for a chosen date. A terminated subscription cannot be restarted -- suspend_subscription is the reversible one.

Inputs: subscription_id (required), immediate, termination_date.

update_billing_addressUpdate a customer's billing address (write)C

WRITE. Updates the billing address of a ProAbono customer. Only the fields passed are changed. The address is what invoices are issued against, and the tax identifier is what VAT treatment is derived from, so it must be the customer's own data -- never a placeholder.

Inputs: customer_ref (required), city, phone, region, +8 more.

upgrade_subscriptionMove a subscription to another offer (write)A

WRITE. Moves a ProAbono subscription to another offer -- an upgrade or a downgrade, the same operation either way. It terminates the current subscription and creates a new one on the target offer, which means the returned identifier is a new one and the customer's rights change: re-read them with get_usages afterwards, and stop using the old identifier. By default the move takes effect at the end of the current term; set immediate to apply it now.

Inputs: offer_ref (required), subscription_id (required), bill_now, immediate, +1 more.

verify_insite_installationVerify the In-Site installation, and run the go-live checklist (write)A

WRITE. Checks an In-Site installation before it ships. It exercises steps 2 and 3 against the account for real. Its one write makes sure the customer it verifies against exists: the customer_ref given is upserted with its reference and Segment only -- created if missing, left unchanged if it exists -- and without one a new customer is created under a generated mcp-verify- reference. It then confirms an object comes back carrying the insite-* workflow query, and reads the Usage API for that customer, diagnosing an empty answer instead of calling it 'no rights'. It checks the developer's own files statically against the rules of the go-live checklist: no secret inlined, no customer reference from the request, no branch on ReferenceOffer, the cache replaced rather than merged, IsEnabled enforced, pagination read whole. And it reports what no API can verify -- the workflow redirect URL, the webhook validation, and the snippet's presence in the page -- as pending rather than pretending. Ends with the twelve-item go-live checklist. Run it before shipping, not after.

Inputs: offer_ref, customer_ref, project_root.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 43 tools

    Disambiguation5/5

    Despite 43 tools, purposes are sharply distinct and descriptions proactively resolve overlaps: push_usage_increment/quantity/enabling are split by Feature type, get_invoice vs get_credit_note are explicitly contrasted, and list_offers vs list_offers_for_customer vs get_offer are each scoped. Task-specific generators (install_customer_portal, link_subscription_workflow, sync_usage_rights, scaffold_notification_endpoint) are clearly delineated from the generic generate_integration_code.

    Naming Consistency4/5

    Overwhelmingly consistent snake_case with a verb_noun pattern (get_offer, list_offers, create_subscription, push_usage_increment, set_invoice_note). A few deviate into noun-phrase form (installation_status, get_server_info) or compound orchestration names (install_insite, verify_insite_installation), but the convention stays readable throughout.

    Tool Count2/5

    43 tools is far beyond the 25+ threshold that signals an over-heavy surface, and it forces an agent to reason across installation, subscription, usage, invoice and settings families before acting. Each tool is genuinely distinct, but the sheer breadth raises misselection risk and cognitive load considerably for a single server.

    Completeness5/5

    The surface covers the full billing lifecycle: customer upsert/anonymize, billing address read/update, payment settings, subscriptions (create/start/suspend/terminate/upgrade/get/list), usages (quote and three push modes), invoices and credit notes, balance-to-invoice billing, plus installation orchestration, verification, planning, docs and API-contract tools. Remaining gaps (offer/catalogue editing, de-anonymization) are explicitly out of scope and handled in the BackOffice.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      B
      maintenance
      Enables AI assistants to operate the Ribbo recurring billing API, allowing them to manage subscriptions, check entitlements, refund payments, charge immediately, and generate payment or renewal links.
      24
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      Enables AI assistants like Claude Code or Cursor to interact with a PNLCS billing panel, querying and managing clients, invoices, orders, tickets, and transactions via natural language.
      15
      63 npm
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables AI assistants to search API documentation, retrieve endpoint details, get SDK snippets, and check changelogs from an OpenAPI spec.
      7
      104 npm
      4
      MIT
    • A
      license
      A
      quality
      A
      maintenance
      Enables coding assistants to install and configure ProAbono in a website by providing access to ProAbono documentation, the live API, and the user's own account configuration to generate integration code, inspect account data, and create test data.
      16
      MIT