+
+
+
+Welcome, {customer?.name || "user"}!
; +}; +``` + +```typescript Node.js +import { Autumn } from "autumn-js"; + +const autumn = new Autumn({ + secretKey: 'am_sk_42424242', +}); + +const { data, error } = await autumn.customers.create({ + id: "org_123", + name: "Acme Corp", + email: "admin@acme.com", +}); +``` + +```python Python +import asyncio +from autumn import Autumn + +autumn = Autumn('am_sk_42424242') + +async def main(): + customer = await autumn.customers.create( + id="org_123", + name="Acme Corp", + email="admin@acme.com", + ) + +asyncio.run(main()) +``` + +```bash cURL +curl --request POST \ + --url https://api.useautumn.com/v1/customers \ + --header 'Authorization: Bearer am_sk_42424242' \ + --header 'Content-Type: application/json' \ + --data '{ + "id": "org_123", + "name": "Acme Corp", + "email": "admin@acme.com" + }' +``` + +Welcome, {customer?.name || "user"}!
; +}; +``` + +```typescript Node.js +import { Autumn } from "autumn-js"; + +const autumn = new Autumn({ + secretKey: 'am_sk_42424242', +}); + +const { data, error } = await autumn.customers.create({ + id: "user_123", + name: "Jane Doe", + email: "jane@example.com", +}); +``` + +```python Python +import asyncio +from autumn import Autumn + +autumn = Autumn('am_sk_42424242') + +async def main(): + customer = await autumn.customers.create( + id="user_123", + name="Jane Doe", + email="jane@example.com", + ) + +asyncio.run(main()) +``` + +```bash cURL +curl --request POST \ + --url https://api.useautumn.com/customers \ + --header 'Authorization: Bearer am_sk_42424242' \ + --header 'Content-Type: application/json' \ + --data '{ + "id": "user_123", + "name": "Jane Doe", + "email": "jane@example.com" + }' +``` + +
+
+
+
+
+
+
+Welcome, {customer?.name || "user"}!
; +}; +``` + +```typescript Node.js +import { Autumn } from "autumn-js"; + +const autumn = new Autumn({ + secretKey: 'am_sk_42424242', +}); + +const { data, error } = await autumn.customers.create({ + id: "org_123", + name: "Acme Corp", + email: "admin@acme.com", +}); +``` + +```python Python +import asyncio +from autumn import Autumn + +autumn = Autumn('am_sk_42424242') + +async def main(): + customer = await autumn.customers.create( + id="org_123", + name="Acme Corp", + email="admin@acme.com", + ) + +asyncio.run(main()) +``` + +```bash cURL +curl --request POST \ + --url https://api.useautumn.com/customers \ + --header 'Authorization: Bearer am_sk_42424242' \ + --header 'Content-Type: application/json' \ + --data '{ + "id": "org_123", + "name": "Acme Corp", + "email": "admin@acme.com" + }' +``` + +
@@ -33,7 +33,8 @@ Create a `metered` `consumable` feature for our premium messages, so we can trac
+Create a free plan, and assign 10 messages to it. We'll add an interval of "month", so that the user is granted 10 periodically.
-Now we'll create our top-up plan. We'll add a price to our premium messages feature, at $10 per 100 messages. These are "one-off" purchases, with a `prepaid` billing method.
+**Top up Plan** +Now we'll create our top-up plan. Again, we'll assign the messages feature, but this time with a `prepaid` price of $10 per 100 messages. -`prepaid` features require a `quantity` to be sent in when a customer attaches this product, so the customer can specify how many premium messages they want to top up with. +Since these messages have interval "one-off", the messages will last forever (unlike our Free plan messages, which reset every month). + +Features with a `prepaid` price require a `quantity` to be passed in when a customer purchases the plan, so the customer can specify how many messages they want to top up with.
@@ -61,7 +65,7 @@ Now we'll create our top-up plan. We'll add a price to our premium messages feat
+
+);
+```
+
+```typescript Node.js [expandable]
+import { Autumn } from "autumn-js";
+
+const autumn = new Autumn({
+ secretKey: 'am_sk_42424242',
+});
+
+const { data } = await autumn.customer({
+ customer_id: "user_or_org_id_from_auth",
+});
+
+const messages = data?.features?.messages;
+
+// Extract monthly vs prepaid balances from the breakdown
+const monthlyBalance = messages?.breakdown?.find(
+ (b) => b.interval === "month"
+);
+const prepaidBalance = messages?.breakdown?.find(
+ (b) => b.interval === "lifetime"
+);
+
+console.log(`Monthly: ${monthlyBalance?.balance ?? 0} remaining`);
+console.log(`Prepaid: ${prepaidBalance?.balance ?? 0} remaining`);
+console.log(`Total: ${messages?.balance ?? 0} messages available`);
+```
+
+```python Python [expandable]
+import asyncio
+from autumn import Autumn
+
+autumn = Autumn("am_sk_42424242")
+
+async def main():
+ response = await autumn.customer(
+ customer_id="user_or_org_id_from_auth",
+ )
+
+ messages = response.features.get("messages", {})
+ breakdown = messages.get("breakdown", [])
+
+ # Extract monthly vs prepaid balances
+ monthly = next((b for b in breakdown if b.get("interval") == "month"), None)
+ prepaid = next((b for b in breakdown if b.get("interval") == "lifetime"), None)
+
+ print(f"Monthly: {monthly['balance'] if monthly else 0} remaining")
+ print(f"Prepaid: {prepaid['balance'] if prepaid else 0} remaining")
+ print(f"Total: {messages.get('balance', 0)} messages available")
+
+asyncio.run(main())
+```
+
+```bash cURL
+curl -X GET "https://api.useautumn.com/v1/customers/user_or_org_id_from_auth" \
+ -H "Authorization: Bearer am_sk_42424242" \
+ -H "Content-Type: application/json"
+
+ # get features usage object from customer.features.[feature_id]
+```
+
+Monthly: {monthlyBalance?.balance ?? 0} remaining
+Prepaid: {prepaidBalance?.balance ?? 0} remaining
+Total: {messages?.balance ?? 0} messages available
++Because check runs before the action, Autumn becomes your system of record for pricing and entitlements. + +With other providers, billing is asynchronous: you send usage, they generate invoices later, and _you own the logic and state in between_ — who gets access, when limits apply, how downgrades work etc. + +Autumn owns that layer. Credit ledgers, real-time enforcement and spend caps work out of the box. Edge cases around upgrades, downgrades, and failed payments are handled automatically — users always get access to what they've paid for. + +That also makes scaling challenges much simpler. Changing pricing, migrating plans, handling downgrades, setting up custom enterprise contracts with rollovers, or launching team billing with per-seat allowances become configuration changes instead of messy logic rewrites. + + +**Architecturally**
+`check` is designed to be called inline, before every AI generation, API request, or feature gate. We achieve response times of under 50ms via multi-region caching, with atomic handling of concurrent requests so credit balances and usage limits stay consistent even at scale. + +Unlike other billing providers, Autumn is built on top of Stripe billing instead of replacing it. Your subscriptions, customers, and payment details live in your own Stripe account, so you're never "locked in". + +