canonical: https://jentic.com/apis/monsitools.com/monsitools

# MonsiTools Calculation API

The MonsiTools Calculation API runs any of several hundred named calculators and returns the numeric result as JSON. A request names the calculator by its slug, such as customer-lifetime-value-ltv-calculator, break-even-calculator, or ai-token-cost-calculator, and passes a value for every input the tool declares. A public tool listing returns each calculator's name, category, input ids, and formula, so a client knows what to send before calling. Premium accounts can also check key status and monthly usage, and create or revoke their API key.

## For AI agents

Run a named MonsiTools calculator, such as break-even, CAC payback, or AI token cost, by slug with its inputs and get the numeric result back as JSON.

## Scope

Does not store spreadsheets, evaluate free-form math expressions, or fetch live market prices. Use for running named MonsiTools calculators with supplied inputs only.

## Capabilities

- Compute a business, finance, marketing, or AI-cost metric by calculator slug with its declared inputs
- List every calculator with its name, category, input ids, and formula from /api-tools.json
- Catch missing inputs as a missing_inputs error instead of a silent zero
- Read API key status, the key hint, and this month's call and error counts with top tools
- Create a replacement API key or revoke the account's current key

## Use cases

### AI analyst agent that runs calculators on demand

An agent answering a business question needs a reliable formula rather than doing arithmetic in its own reasoning. Through Jentic the agent searches for 'run a break-even calculation', loads the MonsiTools calculate operation with its input schema, reads the calculator's input ids from the tool listing, and sends the values. The mt_live_ API key is attached by your own Jentic One instance, so the agent only sees the slug, inputs, and result.

Example prompt: Fetch GET /api-tools.json to read the inputs for break-even-units-calculator, then call POST `/api/calculate` with slug break-even-units-calculator and those inputs, and return the result

### SaaS and marketing metric checks

Growth and finance teams often need the same metrics computed the same way: CAC payback period, LTV to CAC ratio, churn rate, ARR, and ROAS. MonsiTools exposes each as a named calculator slug, so a report or spreadsheet job can send the raw figures and get a consistent number back. Each response echoes the inputs it used alongside the result.

Example prompt: Call POST `/api/calculate` with slug customer-lifetime-value-to-cac-ratio-calculator and the inputs listed for it in /api-tools.json, then report the ratio

### Estimating AI usage costs

Developers budgeting an agent deployment can use calculators such as ai-token-cost-calculator, ai-agent-cost-per-run-calculator, and ai-context-window-calculator to estimate spend before scaling up. Each takes the calculator's declared inputs and returns a single numeric result.

Example prompt: Call POST `/api/calculate` with slug ai-agent-cost-per-run-calculator and the token and price inputs listed for it in /api-tools.json

### Monitoring calculation usage

Premium account holders track how their key is used. GET `/api/keys` returns whether a key exists, its last four characters, and usage for the month, including calls, errors, top tools, and the last status. It requires a signed-in session token rather than the calculation key.

Example prompt: Call GET `/api/keys` with a signed-in session token and report this month's calls, errors, and the top three tools by calls

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/calculate` | Run a calculator |
| GET | `/api-tools.json` | List every tool with its input ids |
| GET | `/api/keys` | Key status and this month's usage |
| POST | `/api/keys` | Create or replace the API key |
| DELETE | `/api/keys` | Revoke the API key |

## Key resources

- **Calculate** — Run one calculator by slug with a value for each declared input
- **Tool listing** — Public map of calculator slug to name, category, input ids, formula, and premium flag
- **API keys** — Key status and monthly usage, key creation, and key revocation

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 61 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 93 / 100
  - Developer Experience & Jentic Compatibility: 66 / 100
  - AI-Readiness & Agent Experience: 41 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 53 / 100
- **View full report:** https://jentic.com/apis/monsitools.com/monsitools/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring MonsiTools by hand means issuing an mt_live_ key from the dashboard, sending it as a bearer token, and looking up each calculator's input ids before the first call. Through Jentic you install once, import MonsiTools from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** The calculator slug travels in the request body, so rules bound which operations your agent may call, not which calculator it runs. You choose the operations it may call, so key management ones like creating or revoking the API key are not included unless you add them.
- **Credential handling:** Your MonsiTools API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'calculate customer lifetime value' or 'estimate AI token cost', and Jentic returns the MonsiTools calculate operation with its input schema, including the slug enum and inputs object.

## Related APIs

- **Newton API** — Symbolic math on free-form expressions: simplify, derive, integrate
- **ActiveCalculator** — Account-hosted calculators with webhook delivery of calculator events
- **Numbers API** — Spell numbers as words, convert bases, and run prime checks

## FAQ

### What authentication does the MonsiTools Calculation API use?

The spec declares HTTP bearer authentication. POST `/api/calculate` takes an API key in the form mt_live_... from Dashboard > API access, sent as Authorization: Bearer, while the `/api/keys` operations expect a signed-in session token instead. GET /api-tools.json is public and needs no token. Through Jentic the key is stored by your own Jentic One instance and attached at call time.

### How do I know which inputs a MonsiTools calculator needs?

Call GET /api-tools.json. It returns a map of calculator slug to its name, category, input ids, formula, and whether it is premium. POST `/api/calculate` requires every input the tool lists; a missing one returns the missing_inputs error rather than computing with a zero.

### What are the rate limits for the MonsiTools Calculation API?

The OpenAPI spec states that Premium accounts get 60 requests per minute. Over that limit the API returns the rate_limited error, so an agent running many calculations should pace its calls.

### Is there a MonsiTools MCP server?

You don't need an MCP server to give your agent MonsiTools. Jentic connects it directly from the API Directory: import it, store your API key once, and your agent runs calculators on demand without another server's tool definitions in its context.

### Can I limit what my agent is allowed to do with the MonsiTools Calculation API?

Yes. Write a rule that allows only POST `/api/calculate` and GET /api-tools.json, so the agent can look up calculators and run them but cannot create a new key or revoke the one you use. Every call it makes is logged.

### How do I run a calculator through Jentic?

Search Jentic for 'run a break-even calculation', load the POST `/api/calculate` operation, and execute it with the slug and an inputs object keyed by the calculator's input ids. The response returns the name, the inputs used, and the numeric result. To run it on your own infrastructure, install Jentic One from its GitHub repo.
