Zovo Bill Splitter
Server Details
Split the bill without the awkward math.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 3 tools
Each tool targets a clearly distinct scenario: a single bill, a group's multiple shared expenses, and rent/housing costs. The descriptions explicitly cross-reference each other with guidance on which tool to use, eliminating overlap.
All three names follow a consistent snake_case verb_noun pattern: settle_group_expenses, split_bill, split_rent. The verbs are precise and the nouns clearly identify the domain object.
Three tools is well-scoped for a bill-splitting server, with one tool per major use case and no redundant variants. Each tool earns its place.
The surface covers the main bill-splitting scenarios: individual bills, group expense settlement, and rent with utilities. Minor gaps exist for edge cases like standalone utility splitting without rent or multi-currency handling, but these are explicitly scoped out.
Available Tools
3 toolssettle_group_expensesSettle group expensesARead-onlyIdempotentInspect
Use this when a group (trip, vacation, roommates, couple, event) has several shared expenses paid by different people and wants to know who owes who and how to settle up. Each expense can be split equally, by exact amounts, by percentages, or by shares. Returns each person's balance (paid minus share, summing to exactly zero) and the fewest payments that settle every balance to the cent, plus a CSV of payments, balances, and expenses. One currency per call: mixed currencies are rejected and nothing is converted. Does not send payment requests, move money, or remember the group; for one restaurant bill use split_bill.
| Name | Required | Description | Default |
|---|---|---|---|
| title | No | Optional label, e.g. "Lisbon trip". | |
| people | No | Everyone in the group, e.g. ["Ana", "Ben", "Chloe", "Dev"]. Needed when "everyone" should include someone who never paid. Optional otherwise. | |
| currency | No | ISO 4217 code for every expense, e.g. USD, EUR, GBP. Defaults to USD. Mixed currencies are rejected; nothing is converted. | |
| expenses | Yes | Every shared expense. Example: [{"description": "Airbnb", "amount": 360, "paid_by": "Ana"}, {"description": "Gas", "amount": 90, "paid_by": "Ben", "split_among": ["Ben", "Chloe"]}]. Record a repayment already made as an expense paid_by the person who paid it back, with split_among set to the person who received it. |
Output Schema
| Name | Required | Description |
|---|---|---|
| kind | Yes | |
| hints | Yes | |
| title | Yes | |
| people | Yes | |
| totals | Yes | |
| display | Yes | |
| minimal | Yes | |
| currency | Yes | |
| expenses | Yes | |
| warnings | Yes | |
| downloads | Yes | |
| transfers | Yes | |
| minor_units | Yes | |
| expense_count | Yes | |
| expenses_shown | Yes | |
| transfer_count | Yes | |
| nonzero_balances | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint and destructiveHint=false, but the description adds substantial beyond-annotation context: balances sum to exactly zero, the tool computes the fewest payments, mixed currencies are rejected with no conversion, and it does not send payment requests, move money, or persist the group. These are behavioral guarantees an agent can't get from the annotations alone.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with when-to-use, then split modes, then return values, then boundaries and sibling routing. Dense but every sentence carries information; no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
A read-only computation tool with an output schema and full param coverage. The description still adds the zero-sum guarantee, minimal-payments property, currency constraint, and non-persistence, which are the things an agent most needs to trust before calling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents split modes, split_among, and split_values. The description reinforces the four split modes and the one-currency-per-call constraint, but adds little semantic detail beyond the schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource (settle group expenses) and immediately scopes it to multi-expense groups like trips, roommates, and events. It explicitly distinguishes itself from the sibling split_bill by telling the agent to use split_bill for a single restaurant bill.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives a clear triggering condition ('several shared expenses paid by different people') and an explicit exclusion routing to the alternative ('for one restaurant bill use split_bill'). Mixed-currency rejection and the no-money-movement boundary are also spelled out, so the agent knows when this tool is and isn't appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
split_billSplit a billARead-onlyIdempotentInspect
Use this when the user wants to split a restaurant bill, check, receipt, takeout order, or any single bill between people: evenly or item by item (who had what), with tax, tip, service charge, coupons, delivery fees, or rounding up. Tax, tip, and service charge are shared in proportion to each person's pre-tax subtotal; every share is exact to the cent and the shares add up exactly to the total (largest-remainder rounding). Optional paid_by lists who owes the payer. Does not read receipt photos (pass the items as text), handle several payers or many bills (use settle_group_expenses), or convert currencies.
| Name | Required | Description | Default |
|---|---|---|---|
| items | No | Line items from the receipt with who shared each one. Example: [{"description": "Pizza", "price": 24, "shared_by": ["Ana", "Ben"]}, {"description": "Salad", "price": 12, "shared_by": ["Chloe"]}]. Omit and use bill_amount to split one total evenly. | |
| title | No | Optional label, e.g. "Dinner at Luigi's". | |
| people | No | Everyone splitting the bill, e.g. ["Ana", "Ben", "Chloe"]. Needed when some items are shared by everyone or when someone had nothing. Optional if every item lists shared_by. | |
| paid_by | No | Who paid the whole bill, e.g. "Ana". Adds a list of who owes them how much. | |
| currency | No | ISO 4217 code, e.g. USD, EUR, GBP, JPY. Defaults to USD. JPY has no decimals, KWD has three. | |
| tip_base | No | What tip_percent applies to: pre_tax (default, subtotal after discounts) or post_tax (subtotal plus service charge plus tax). | |
| tax_amount | No | Tax in money exactly as printed on the receipt, e.g. 7.38. Shared in proportion to each person's subtotal. | |
| tip_amount | No | Tip in money, e.g. 25. Shared in proportion to each person's subtotal. | |
| bill_amount | No | Use instead of items to split one amount evenly, e.g. 120. It is the amount before any tax_percent or tip_percent you add here; if the bill already includes tax, leave tax out. | |
| round_up_to | No | Round each person's share up to a multiple of this amount, e.g. 1 for whole dollars or 5. The extra is shown separately. | |
| tax_percent | No | Sales tax or VAT rate added on top of the item subtotal (after any discount), e.g. 8.875. Use tax_amount instead when the receipt shows the tax in money. | |
| tip_percent | No | Tip rate, e.g. 18 or 20. Calculated on the pre-tax subtotal unless tip_base is post_tax. | |
| people_count | No | Number of people when names are not given, e.g. 5. They are labelled Person 1 to Person 5. | |
| discount_amount | No | Coupon or deal on the whole bill in money, applied before tax, e.g. 15. | |
| discount_percent | No | Coupon or deal on the whole bill in percent, applied before tax, e.g. 10. | |
| equal_fee_amount | No | A flat fee split equally rather than by what people ordered, e.g. a 6.99 delivery fee or a cover charge. | |
| service_charge_amount | No | Service charge in money, e.g. 9.75. | |
| service_charge_percent | No | Service charge rate added by the restaurant, e.g. 12.5. Shared in proportion to each person's subtotal. |
Output Schema
| Name | Required | Description |
|---|---|---|
| kind | Yes | |
| owes | Yes | |
| check | Yes | |
| hints | Yes | |
| items | Yes | |
| title | Yes | |
| labels | Yes | |
| people | Yes | |
| totals | Yes | |
| display | Yes | |
| paid_by | Yes | |
| currency | Yes | |
| settings | Yes | |
| warnings | Yes | |
| minor_units | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds substantial behavior beyond the annotations: tax, tip, and service charge are shared proportionally to pre-tax subtotal, shares are exact to the cent using largest-remainder rounding, and paid_by produces who-owes-whom output. It also discloses practical limitations such as no photo OCR and no currency conversion.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the primary use case and then layers in exclusions and behavioral notes. Despite covering a complex 18-parameter tool, every sentence carries actionable information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the rich input schema, existing output schema, and clear annotations, the description supplies the remaining high-value context an agent needs. It covers when to use it, key calculation behavior, and the main boundaries relative to alternatives.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3 even without extra parameter explanation. The description adds useful semantics around proportional sharing and exact cent rounding, though it does not discuss most of the 18 parameters directly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource, 'split ... bill', and defines scope as a single bill between people, including even or itemized splitting. It also distinguishes itself from the sibling tool settle_group_expenses for many bills or several payers.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states when to use the tool, including restaurant bills, receipts, takeout orders, and single bills. It also gives clear exclusions and alternatives: no receipt-photo reading, no multiple payers or many bills (use settle_group_expenses), and no currency conversion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
split_rentSplit rentARead-onlyIdempotentInspect
Use this when roommates or housemates want to split rent fairly: by bedroom size (square feet or metres) with a shared-space portion split per occupant, by income, or equally, with optional per-room adjustments (private bathroom, no window), couples sharing a room, and utilities split per occupant. Every amount is exact to the cent and the parts add up exactly to the rent. Does not give legal or tenancy advice, collect rent, or handle one-off shared expenses (use settle_group_expenses for those).
| Name | Required | Description | Default |
|---|---|---|---|
| basis | No | How to split: room_size (default when every room has a size), income (in proportion to income), or equal (per occupant). | |
| rooms | Yes | Each bedroom or person. Example: [{"name": "Ana", "size": 160}, {"name": "Ben", "size": 120}, {"name": "Chloe", "size": 100}]. | |
| currency | No | ISO 4217 code, e.g. USD, EUR, GBP. Defaults to USD. | |
| total_rent | Yes | Total monthly rent for the home, e.g. 3200. | |
| extra_costs | No | Other monthly costs split equally per occupant, e.g. 180 for utilities and internet. | |
| shared_area | No | Area of shared space (kitchen, living room, shared bathroom) in the same unit as the room sizes, e.g. 400. Its share of the total area is split equally per occupant. | |
| shared_percent | No | Alternative to shared_area: percent of the rent treated as shared space and split equally per occupant, e.g. 40. Defaults to 50 for room_size when shared_area is not given. |
Output Schema
| Name | Required | Description |
|---|---|---|
| kind | Yes | |
| basis | Yes | |
| hints | Yes | |
| rooms | Yes | |
| totals | Yes | |
| display | Yes | |
| currency | Yes | |
| settings | Yes | |
| warnings | Yes | |
| assumptions | Yes | |
| minor_units | Yes | |
| shared_source | Yes | |
| shared_percent | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already establish that this is a read-only, idempotent, non-destructive operation. The description adds useful behavior beyond that: every amount is exact to the cent and the parts add up exactly to the rent, and it clarifies that the tool does not collect rent or give legal advice.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The definition is front-loaded with the usage trigger and then adds the arithmetic guarantee and exclusions. The first sentence is dense with many clauses, but overall there is little wasted text and no repetition of schema details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a seven-parameter tool with a full output schema and strong annotations, the description covers purpose, supported splitting bases, arithmetic guarantees, and key exclusions. An agent has enough information to decide when to call it and what behavior to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all seven parameters in detail. The description reinforces concepts such as shared-space splitting per occupant and per-room adjustments, but it does not add syntax or edge-case semantics beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource — splitting rent among roommates — and enumerates the supported bases (room size, income, equal), adjustments, couples, and utilities. It also distinguishes itself from settle_group_expenses for one-off shared expenses, so an agent can tell what it is for without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives a clear trigger (roommates or housemates wanting to split rent fairly) and an explicit exclusion for one-off shared expenses with a named alternative, settle_group_expenses. The other sibling, split_bill, is not mentioned, leaving a small gap in routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
- First observed
settle_group_expenses - First observed
split_bill - First observed
split_rent
Related MCP Connectors
Split shared expenses in a group — no account needed. See who owes whom and settle up.
Split bills from your AI: read bills & balances, create equal splits, request settlements.
Create a bill from a chat/photo and share it with anyone
Split rent and utilities by room, settle up and generate roommate agreements. Free.
Related MCP Servers
- AlicenseCqualityBmaintenanceEnables turning receipt photos into checked, per-person expense splits with exact-cent reconciliation.5MIT
- AlicenseNot gradedqualityAmaintenanceRuns an entire shared-expense split from an assistant: create one, add what each person paid (equally, by weighted shares or exact amounts), record paybacks, and read back who owes whom as the fewest transfers. Eleven tools covering the whole lifecycle, with no account and no API key — people are referred to by name and amounts are plain decimals, so an agent never handles uuids or cents.4MIT
- AlicenseNot gradedqualityBmaintenanceEnables splitting bills and collecting PayNow payments from AI chat, generating shareable payment links and tracking payment status.31 npmMIT
- FlicenseAqualityBmaintenanceEnables AI agents to manage SplitBill bills and friends through natural language: create bills from receipts, list and filter bills, update payment statuses, search users, and view dashboard stats.7-
Glama MCP Gateway
Add one secure layer between your agents and this server.