Connect Your Invoicing to AI: How SolidInvoice's MCP Server Works

If you've ever wished you could just tell your invoicing tool what to do (think "send the May retainer to Acme," or "show me everything overdue more than two weeks," or "draft a polite reminder for invoice #1042"), that wish is now plumbing, not science fiction. The Model Context Protocol (MCP) makes it possible, and SolidInvoice ships with an MCP server out of the box.

This post covers what MCP is, why it's a meaningful shift for tools like invoicing, and how to connect SolidInvoice to Claude, ChatGPT, Cursor, or any other MCP-compatible AI client.

What is MCP, in plain English?

The Model Context Protocol is an open standard for letting AI assistants talk to your tools. Think of it as a universal adapter. Instead of every AI assistant building custom integrations with every app (and every app building custom plugins for every AI), both sides speak MCP, and they just work together.

A practical analogy: USB-C didn't make new devices possible, but it removed the friction of every device shipping a different cable. MCP is doing the same thing for AI integrations.

In practice, an MCP server is a small piece of software that:

Exposes a set of tools (actions the AI can take, like create_invoice or list_clients)
Exposes a set of resources (data the AI can read, like a list of overdue invoices)
Authenticates the AI on your behalf, so it acts only with permissions you grant

The AI client (Claude Desktop, ChatGPT, Cursor, Zed, Continue, and a growing list of others) discovers what the server can do and uses it as needed. You don't write code. You just have a conversation.

Why MCP matters more for invoicing than for most tools

Invoicing is one of those jobs where the thinking is small but the doing is repetitive. You already know who to bill, how much, and when. The work is just typing it into a form, hitting send, and chasing the response. That's exactly the kind of work AI is good at, provided it can reach into the system.

Before MCP, the options for AI-assisted invoicing were limited:

Copy and paste. Ask the AI to draft something, then move it manually into your invoicing tool.
Custom integrations. Wire up Zapier or build something against the API, locked to one provider.
Browser automation. Brittle, slow, and breaks every time the UI changes.

MCP collapses that into a direct conversation. The AI knows your invoices exist, knows their state, knows your clients, and can act on them. The friction between "I should bill that client" and "the invoice is sent" drops from a four-minute task to one sentence.

A few things this unlocks:

Natural-language billing. "Bill Acme for 12 hours of consulting at my standard rate, due in 30 days." Done.
Smarter follow-ups. "Show me invoices overdue more than two weeks, and draft reminders matching the tone of my last successful one."
Cross-tool workflows. Pair SolidInvoice's MCP server with a calendar MCP, a Slack MCP, or a project-management MCP, and the AI can stitch them together: pulling hours from a tracker, generating the invoice, and notifying the client in one flow.
Reporting on demand. "What's my outstanding A/R?" without opening a dashboard.

The net effect: invoicing stops being a context switch. It happens inside whatever tool you're already in.

What you can do with the SolidInvoice MCP server

SolidInvoice's MCP server exposes the most common invoicing actions as tools the AI can call directly. Among them:

Clients: create, update, and look up clients and contacts
Quotes: draft, send, and track quotes
Invoices: create, send, mark paid, and pull status
Recurring invoices: schedule and manage retainer billing
Payments: record payments and reconcile against invoices
Reports: pull aged receivables, totals by client, and other queries

Because the AI is operating against your real data, you can ask things you'd usually need to hunt for:

"Which clients have I invoiced more than $5,000 this quarter, and how much of that is still outstanding?"

"Pull up the last three invoices for Acme, then draft a quote for the same scope at a 10% increase."

"Summarise my recurring billing for May. Anything missing or overdue?"

The AI doesn't replace the workflow (you still review and approve before things hit the wire), but the typing goes away.

A note on safety: you're in control

Letting an AI act on your billing data sounds scary until you understand the model. A few things to know:

You authenticate the connection. The MCP server only acts as the user it's connected on behalf of, with that user's permissions. It can't do anything you can't do.
Most clients ask before destructive actions. Claude Desktop, for example, prompts you before any tool call. You can review what the AI is about to send before it happens.
Self-hosted means self-controlled. If you run SolidInvoice on your own server, the MCP traffic stays on your infrastructure.
Audit trails still exist. Every invoice action is logged in SolidInvoice the same way it would be if you clicked through the UI. There's no "off the books" path through MCP.

The right mental model: MCP gives the AI a steering wheel, not the keys. You stay in the seat.

Setting it up

The MCP server is built into SolidInvoice and enabled by default in version 3.0. There's nothing to install separately, and on the hosted version there are no settings to toggle. You just point your AI client at the MCP endpoint and authorize it from your browser.

The endpoint

Hosted (Cloud SaaS): https://solidinvoice.app/_mcp
Self-hosted: https://<your-solidinvoice-host>/_mcp

The transport is Streamable HTTP (not stdio), so any client that supports remote MCP servers can connect directly.

Self-hosted: one-time setup

If you self-host SolidInvoice, there's a small one-time setup the first time you bring up the MCP server:

bin/console mcp:keys:generate
bin/console doctrine:migrations:migrate

That generates the OAuth signing keys and applies the database migrations. Your instance must also be reachable over HTTPS, since OAuth redirects break on plain HTTP. For local testing, a tunnel like Cloudflare Tunnel or ngrok works.

Authorization: OAuth, not API keys

Authorization uses OAuth 2.1 with dynamic client registration, so you don't generate or paste API keys anywhere. The flow looks like this:

Add the SolidInvoice MCP server to your AI client.
The client opens a browser tab to SolidInvoice's consent page.
You sign in (if you aren't already), pick which company the agent should act on, and choose scopes:
- mcp:read: list and fetch invoices, clients, payments, reports, etc. (mandatory)
- mcp:write: create/update/delete invoices, clients, payments, etc. (optional)
SolidInvoice issues an access token (24 hours) and a refresh token (90 days), bound to that company and scope choice.

You can review and revoke connected agents at any time from /profile/connected-apps in your SolidInvoice account. Revocation invalidates the tokens immediately.

Connecting your AI client

A few of the most common clients:

Claude Code (CLI):

claude mcp add --transport http solidinvoice https://solidinvoice.app/_mcp

Claude Desktop: Settings → Connectors → Add custom connector. Name it SolidInvoice and paste your /_mcp URL.

Cursor: Settings → MCP → Add new MCP server, pointing at the /_mcp URL.

Codex CLI: add the following to ~/.codex/config.toml:

[mcp_servers.solidinvoice]
url = "https://solidinvoice.app/_mcp"

Goose: add a Remote (HTTP) extension pointing at the /_mcp URL.

MCP Inspector (handy for testing): npx @modelcontextprotocol/inspector https://solidinvoice.app/_mcp

Anything else: any agent that supports Streamable HTTP transport, OAuth 2.1 with PKCE, and Dynamic Client Registration (RFC 7591) will work. The full setup matrix and troubleshooting tips live in the SolidInvoice MCP server docs.

Once connected, a quick smoke test:

"What MCP tools do you have available from SolidInvoice?"

You should see a list of the actions described above. From there, you can start using natural language to drive your invoicing.

A short tour of what to try first

If this is your first time using an MCP server in earnest, here are a few prompts that show the range without being intimidating:

List today's outstanding invoices. A read-only query is the safest starting point. You'll see how the AI formats data from SolidInvoice and how clean the responses are.
Draft (don't send) an invoice. Ask the AI to prepare an invoice for a specific client and amount. Most clients will show you the draft and wait for confirmation. This builds trust before you let it send anything live.
Run a report. "What's my A/R aging by client?" That kind of query normally takes three clicks and a filter. Now it's one sentence.
Chain it with another MCP. If you use a time-tracking tool with an MCP server, ask the AI to pull last week's hours and generate the invoice from them.

Most "wow" moments with MCP come from chaining tools together. Invoicing is rarely the only thing involved in getting paid. There's usually a tracker, a contract, an email thread. MCP lets the AI move between them without you copy-pasting anything.

The bigger picture: why open standards matter here

It would have been easy for SolidInvoice to ship a Claude-only integration, or build a one-off plugin for ChatGPT. We chose MCP because it's open, vendor-neutral, and growing fast. Any AI client that supports the protocol, including ones that don't exist yet, will work with the SolidInvoice MCP server on day one.

That matters for two reasons. First, you don't get locked into one AI vendor's ecosystem. Pick the assistant you like; the integration moves with you. Second, the protocol itself improves over time, and your tools improve along with it without you having to migrate.

For a tool like invoicing, which sits at the centre of how money moves in and out of your business, that durability is exactly the bet you want to make.

Availability

Hosted (Cloud SaaS): Available now at https://solidinvoice.app/_mcp. Enabled by default; just authorize your client.
Self-hosted: Included in the open-source distribution from version 3.0. Run the one-time key-generation and migration commands, then point your client at https://<your-host>/_mcp. See the docs for the full setup, including multi-node session-store config.

If you want to try it without a long commitment, start a free 14-day trial of the hosted version. Connect it to Claude, ask it to list your invoices, and see whether you ever want to type into a billing form again.

SolidInvoice is open-source invoicing built for freelancers and small businesses. The MCP server is one of several integrations designed to remove friction from getting paid. Start your free 14-day trial or read the MCP setup guide to get started.