API Key Onboarding

How to get an API key for the Developer, Business, or Enterprise tier, end to end. The flow is email-driven: you tell us which tier you want and what you're building, we provision the key — typically within one business day for Developer and Business — and deliver it over a secure channel. There is no self-serve signup page or credit-card form yet; that is intentional at this stage.

How it works

The whole flow, at a glance:

1. You email us a key request — the tier you want (per the published rate card), what you're building, which tools you'd call, roughly how often
2. We confirm and provision — Developer and Business keys are typically provisioned within one business day; Enterprise starts with a short scoping conversation to size limits and terms
3. We deliver your Bearer key — a single key sent over a secure channel
4. You plug the key into your MCP client — standard Authorization: Bearer <key> header, no client-code changes beyond that
5. We stay in touch — direct support channel, and a check-in if your usage suggests a different tier would fit better

The whole thing is designed to be low-ceremony. If a paid key doesn't make sense yet, we'll say so and point you back to the anonymous tier — it is free forever and returns byte-identical math.

Step by step

Step 1 — Email us your key request

Send a short note to admin@markcolabs.com with the subject "API Key Request", covering:

• The tier you want — Developer ($49/mo), Business ($99/mo), or Enterprise (custom) per the rate card
• What you're building — one paragraph, plain English
• Which tools you'd be calling (see the API Reference for the list)
• Rough call volume — per day, per week, or peak burst — so we can sanity-check the tier fits
• Any timing constraint — production launch date, procurement window, demo deadline

You do not need to have your MCP client wired up before you email — and you can verify the math on the anonymous tier first, for free, before you commit to anything.

Step 2 — We confirm and provision

For Developer and Business, we confirm the request, agree the secure delivery channel, and provision the key — typically within one business day. Billing is a simple monthly invoice; there is no auto-charging card on file.

For Enterprise, we set up a short scoping call (or continue by email if you prefer) to align on:

• Rate-limit shape — negotiated windows and daily quotas beyond the published ceilings, sized to your expected load with headroom for bursts
• Key topology — separate staging and production keys you can monitor and revoke independently
• Terms — agreement language layered on top of LICENSE-API.md, plus any procurement or security-review paperwork your side needs

Step 3 — We deliver your Bearer key

The maintainer generates the key from an authenticated environment using our key-issuance runbook. The server stores only a SHA-256 hash of the key (per the contract); the plaintext is emitted exactly once at issuance. That key is then delivered to you over a secure channel — never over plaintext email or a public Slack channel. Concretely: a 1Password shared item, a Signal message, or a PGP-encrypted email. We will confirm with you which channel is workable on your end before generating the key.

Step 4 — Plug the key into your MCP client

The endpoint is the same as the anonymous tier — https://mcp.digitalcalculator.info/mcp — but every request now carries an Authorization header:

curl -X POST https://mcp.digitalcalculator.info/mcp \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer <YOUR_KEY_HERE>' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"mortgage_monthly_payment","arguments":{"principal":300000,"annualRatePercent":6.5,"termYears":30}}}'

If you're integrating via an MCP client library, look for its Bearer / API-key config option:

• Claude Custom Connectors — add the key under the connector's "Authentication" field when creating the connector in claude.ai
• MCP Inspector — add the header via the transport configuration panel
• Raw HTTP / SDK — set Authorization: Bearer <key> on every POST to /mcp
• npm shim (@markcolabs/mcp) — the shim forwards the Authorization header from your client to the hosted endpoint; set it in your MCP client config as usual

Once the key is in place, tool responses are byte-identical to what the anonymous tier returns for the same inputs — per the anonymous-parity invariant. What changes is the rate-limit shape (your tier's dedicated per-key limits), the per-key attribution, and the support relationship. See the API Reference for the tool schemas; nothing about the tool contracts changes for authenticated calls.

Step 5 — Ongoing support and changes

After the key is live:

• Support — you have a direct email channel with the maintainer; Business keys get priority triage
• Tier changes — if your usage grows past the Developer limits (or shrinks below them), email us and we'll move you; the key can stay the same, only its limits change
• Cancellation — email us to stop; we revoke the key cleanly and the anonymous tier remains open to you forever
• Feedback — if you hit rough edges, tell us; the roadmap (SLAs, self-serve portal, key rotation UI) is prioritized by what paying integrations actually need

What we ask of you

A paid key is a two-way commitment. From your side, we ask:

• An honest use case — describe what you're actually building; it's how we size limits sensibly and prioritize the roadmap
• Willingness to give feedback — if something doesn't fit, tell us; that is more valuable than silent churn
• Reasonable security hygiene on the key — store it in a secrets manager, don't check it into git, ask us to rotate it if a laptop is lost

FAQ

Can I test the tools without an API key first?

Yes — that is exactly what the anonymous tier is for. Point your MCP client at https://mcp.digitalcalculator.info/mcp with no Authorization header and every tool works. Use the anonymous tier to verify the tool outputs meet your accuracy expectations before you pay for anything. The math is byte-identical between anonymous and authenticated responses (anonymous-parity invariant).

Do you offer free trials of the paid tiers?

The anonymous tier is the trial — it runs the identical math with no signup, so you can validate correctness for free before subscribing. There is no "free trial that auto-converts to paid"; every paid engagement starts explicitly, by email, at the published price.

How does billing work?

Monthly invoice, paid tier price per the rate card. There is no self-serve billing portal or auto-charging card on file yet — we invoice, you pay, and you can stop by email at any time. If your organization needs specific invoicing details (PO numbers, net terms), mention it in your key request.

What happens if I lose my key?

Bearer keys are stored server-side as a SHA-256 hash — we don't have the plaintext either. If you lose the key, email us; we'll revoke the old one and issue a new one via the same secure-channel process from step 3. There is no self-serve rotation UI yet; that is on the roadmap.

Can I get multiple keys for staging and production?

On Enterprise, yes — separate staging and production keys you can independently monitor and revoke are part of the standard shape. On Developer and Business, mention it in your key request; depending on your setup we can usually accommodate it.

References

• Pricing — the published rate card and feature comparison
• Versioning contract — SemVer policy, anonymous-parity invariant, deprecation window
• API Reference — input schemas and output shapes for all 14 tools
• Quickstart — first call in under 5 minutes (anonymous tier)
• FAQ — general questions about the server

Ready to start? Email admin@markcolabs.com with the tier you want and the bullet points from step 1.