canonical: https://jentic.com/apis/getcheddar.com/cheddar

# Getcheddar Cheddar API

Jentic publishes the only available OpenAPI specification for Cheddar API, keeping it validated and agent-ready. Cheddar is a subscription billing and recurring payment platform aimed at SaaS businesses, with a long-running XML-over-HTTP API for managing pricing plans, customers, and their subscriptions. The API provides 10 endpoints covering plans, customer CRUD, subscription edits, customer imports, and bulk delete operations, all secured via HTTP Basic Auth. It is most often used by SaaS backends to provision new subscriptions, change plans, and retrieve plan and customer state on demand.

## For AI agents

Manage SaaS subscription billing through Cheddar - create customers, change subscription plans, retrieve pricing plans, and import or delete customers. Uses HTTP Basic Auth and XML responses.

## Scope

Does not handle one-time card processing, accounting, or tax filing - use for SaaS subscription customer and plan management only.

## Capabilities

- Provision a new SaaS customer on a chosen pricing plan when a signup completes
- Change a customer's subscription to a different plan when they upgrade or downgrade
- Retrieve the full list of pricing plans for a product to render a pricing page
- Look up a single customer record by code for support or reconciliation
- Bulk-import customers from a legacy billing system during migration
- Delete a customer when they cancel and are past retention requirements

## Use cases

### SaaS Signup Provisioning

When a SaaS user completes signup and selects a plan, the backend needs to create the customer record in Cheddar with the right plan code and billing details. The API's customer creation endpoint accepts the plan code, customer identity fields, and payment method, returning the customer record. This is the canonical path from signup form to recurring billing.

Example prompt: On signup, call `POST `/customers/new/productCode/{productCode}`` with the customer fields and chosen plan code, then store the returned customer code in your database.

### Plan Change on Upgrade or Downgrade

When a customer upgrades or downgrades, the application needs to switch their subscription to a different plan code without losing billing continuity. The API's edit-subscription endpoint accepts a customer code and a new plan code and applies the change in line with Cheddar's proration rules.

Example prompt: Call `POST `/customers/edit-subscription/productCode/{productCode}/code/{customerCode}`` with the new plan code and confirm the response shows the updated plan.

### Legacy Billing Migration

Teams moving from a homegrown billing system or another provider need to load thousands of existing customers into Cheddar without manually entering each one. The customer-import endpoint accepts a batch payload, so a one-off migration job can transfer customers en masse, preserving plan codes and billing identifiers.

Example prompt: Call `POST `/customers/import/productCode/{productCode}`` with the prepared customer batch and verify the response counts match the source CSV row count.

### Agent-Driven Subscription Management

An AI agent in a support or admin tool can resolve 'upgrade this customer to the Pro plan' by discovering the edit-subscription operation through Jentic and executing it. The agent never holds the Basic Auth credentials directly - Jentic manages them - and confirms the new plan code back to the user.

Example prompt: Resolve a customer code from the support context and call `POST `/customers/edit-subscription/productCode/{productCode}/code/{customerCode}`` via Jentic, then return the new plan code to the requester.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/plans/get/productCode/{productCode}` | Get all pricing plans |
| GET | `/customers/get/productCode/{productCode}` | Get all customers |
| POST | `/customers/new/productCode/{productCode}` | Create a new customer |
| POST | `/customers/edit/productCode/{productCode}/code/{customerCode}` | Update a customer and subscription |
| POST | `/customers/edit-subscription/productCode/{productCode}/code/{customerCode}` | Edit a subscription's plan |
| POST | `/customers/delete/productCode/{productCode}/code/{customerCode}` | Delete a customer |
| POST | `/customers/import/productCode/{productCode}` | Import customers in bulk |

## Key resources

- **Plans** — Pricing plans for a product; supports list and get-by-code.
- **Customers** — Customer records and their attached subscriptions; supports CRUD plus subscription edit.
- **Promotions** — Promotional codes that can be applied at customer creation or subscription edit time.

## Why Jentic

- **Setup:** Wiring Cheddar by hand means encoding its HTTP basic credentials, parsing its XML responses, and threading the productCode and customerCode through every path yourself. Through Jentic you install once, import the Cheddar API from the API Directory, store the credentials once, and your agent calls it.
- **Permission scoping:** Cheddar puts the product code in the URL path (`/customers/get/productCode/{productCode}`), so a rule can pin your agent to one product: it reads and manages customers and plans for that product and nothing else. You choose the operations it may call, so a customer delete is not included unless you add it.
- **Credential handling:** Your Cheddar username and password are stored once, encrypted, by your own Jentic One instance and injected at execution time. They never enter the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a subscription customer' or 'look up a plan', and Jentic returns the matching Cheddar operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Stripe** — Full-stack payments platform with native subscription billing and broader feature surface.
- **Recurly** — Subscription management platform aimed at mid-market SaaS with advanced dunning and revenue recognition.
- **Chargify (Maxio)** — Subscription billing platform for B2B SaaS with usage-based pricing.
- **Stripe (legacy slug)** — Underlying card processor frequently used as Cheddar's payment gateway.

## FAQ

### Why is there no official OpenAPI spec for Cheddar API?

Cheddar does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Cheddar API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Cheddar API use?

The Cheddar API uses HTTP Basic Authentication. Through Jentic, the credential pair is stored encrypted and the `Authorization: Basic …` header is injected at execution time, so agents never receive the raw username and password.

### Can I change a customer's subscription plan with the Cheddar API?

Yes. Call `POST `/customers/edit-subscription/productCode/{productCode}/code/{customerCode}`` with the new plan code to switch a customer's subscription.

### Can I bulk-import customers into Cheddar?

Yes. Call `POST `/customers/import/productCode/{productCode}`` with the batch payload. This is the typical path for migrating from another billing system.

### How do I create a new customer through Jentic?

Search Jentic for `create a new customer in Cheddar`, load the schema for `POST `/customers/new/productCode/{productCode}``, and execute with the customer fields and plan code. Jentic handles the Basic Auth header from the vault.

### Does the Cheddar API process card payments directly?

Cheddar handles recurring billing on top of an underlying processor; it does not act as a standalone card gateway. Card processing is configured per Cheddar account and billed automatically via the subscription endpoints.

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

Yes. Because your Jentic One instance is self-hosted, your own rules decide which Cheddar operations and credentials the agent may use. Since Cheddar puts the product code in the URL path, such as `/customers/get/productCode/{productCode}`, you can pin the agent to a single product so it only reads and manages customers and plans for that product. You also choose the exact operations it may call, so a destructive action like POST `/customers/delete` stays out of reach unless you explicitly add it.