# Appmake Docs

> Appmake turns a description into a working web app: pages, database, payments, tests and hosting. The work is done by Kalle by Appmake, Appmake's own family of AI models. Developers can use the Kalle by Appmake API and the Platform API at https://api.kalle.build/v1 with keys that start with kalle_sk_.

# Welcome to Appmake

Appmake turns a description into a working app: pages, database, payments, tests and hosting. This page explains how it works and where to go next.

Source: https://appmake.ai/docs/guides/welcome

## What you can build

Appmake builds real web apps, not mock-ups. You describe what you need in a sentence or two, and Appmake plans it, writes the code, tests it in a real browser and puts it online.

People use Appmake for shops and Shopify storefronts, booking sites, CRMs, client portals, internal dashboards, SaaS products with subscriptions, courses, communities and event sites. If it runs in a browser and needs data, it is a good fit.

- [Build your first app](https://appmake.ai/docs/guides/first-app): A five-minute walkthrough from prompt to published app.
- [Plan mode](https://appmake.ai/docs/guides/plan-mode): See the pages, data and price before anything is built.
- [API reference](https://appmake.ai/docs/api/kalle/overview): Call Kalle by Appmake and the Platform API from your own code.

## How a build works

Every app goes through the same four steps. You stay in control at each one, and nothing that costs money or changes live data happens without your approval.

1. **Ask** Appmake asks a few questions where your answer changes what gets built, with a recommended answer already picked.
2. **Plan** You get a plan with the pages, tables, integrations and a credit estimate. You can edit it before you approve.
3. **Build** Appmake writes the code step by step and explains what it is doing in plain words as it goes.
4. **Test and publish** It tests the app in a real browser, fixes what fails and publishes it when you say so.

## Kalle by Appmake

The work inside Appmake is done by **Kalle by Appmake**, our own family of AI models. Kalle by Appmake reads your message, asks questions, writes the plan and the code, and explains each step.

You don't need to choose a model. Leave the builder on **Auto** and Appmake picks the right model for each step, so small edits stay cheap and hard problems get more thinking. Read more in [Kalle by Appmake](https://appmake.ai/docs/kalle/overview).

## What you own

The code, the design and the data are yours. Every app is a standard Next.js project with a Postgres database. You can export the code, sync it to your own GitHub repository and run it anywhere.

> Appmake never trains AI models on your projects, your data or your customers' data.

## Where to go next

- [For founders](https://appmake.ai/docs/guides/first-app): Go from idea to paying customers.
- [For businesses](https://appmake.ai/docs/platform/integrations): Shops, bookings and tools for your team.
- [For developers](https://appmake.ai/docs/api/kalle/overview): APIs, SDKs, webhooks and the code itself.
- [For agencies](https://appmake.ai/docs/platform/agencies): Workspaces, client hand-over and the partner programme.

---

# Build your first app

Go from a sentence to a published app. This walkthrough builds a booking site for a yoga studio, but the steps are the same for any app.

Source: https://appmake.ai/docs/guides/first-app

## 1. Describe your app

Open the builder and write what you want in plain words. Say who the app is for and what people should be able to do. One or two sentences is enough to start.

```text
A booking site for my yoga studio. Members buy 10-class passes,
book classes online and get a reminder email the evening before.
```

> If you have a current website, a screenshot or a Figma file, paste the link. Appmake uses its colours, fonts and texts as the starting point.

## 2. Answer a few questions

Before it plans anything, Appmake asks three to seven questions in a panel next to the preview. Each question has a recommended answer already picked, so you can press **Continue** if the defaults look right.

The questions depend on the kind of app. A webshop asks about payment methods and shipping, a CRM asks about deal stages and email, a booking site asks who takes bookings and how people pay.

## 3. Approve the plan

Appmake shows a plan: the pages, the database tables, the services it will connect and a credit estimate. Planning is free. Credits are only used once you approve and the build starts.

Change anything you like before approving. Remove a page, add a feature or split a big idea into phases. Read more in [Plan mode](https://appmake.ai/docs/guides/plan-mode).

## 4. Watch it build

The chat shows each step while Appmake works: what it is thinking about, which files it writes, which packages it installs and which tests it runs. The preview on the right updates as the app takes shape.

If Appmake needs something from you, such as a Stripe key, it stops and asks with a secure field. Keys go into an encrypted vault and never appear in the chat.

## 5. Publish

When the tests pass, press **Publish**. Your app goes live on a free address like `lotus-yoga.appmake.ai` with TLS switched on. You can connect your own domain at any time from [Domains and hosting](https://appmake.ai/docs/platform/domains).

From here, keep talking to Appmake to change the app, or click on anything in the preview to edit it directly.

---

# Chat and the builder

The builder has the chat on the left and your app on the right. This page explains what you see while Appmake works and how to steer it.

Source: https://appmake.ai/docs/guides/chat

## The builder at a glance

The chat is where you ask for changes. The right side has tabs for **Preview**, **Code**, **Terminal**, **Versions**, **Database** and **Queue**. The live address and the **Publish** button sit at the top.

- **Preview** shows the app as your visitors see it, at desktop, tablet or phone size.
- **Code** shows every file with the right language icon, and the lines changed in the last step.
- **Terminal** shows the build log and a shell inside your app's container.
- **Queue** lists messages you sent while Appmake was busy. You can reorder or remove them.

## What Appmake shows while it works

Each step appears in the chat as it happens, in plain words. You see when Appmake is thinking, reading files, searching the web for documentation, writing code, installing packages, setting up the database, running tests and publishing.

Switch **How Appmake explains its work** between *Plain words* and *Technical* in Settings → Preferences. Technical mode adds file paths, commands and test output.

After every change you get a short summary: what changed, what you will notice, the test result, anything still open from the plan and two or three suggested next steps.

## When Appmake asks before acting

Some actions always wait for your yes, even in the middle of a build:

- Anything that costs money, including steps estimated above 20 credits
- Deleting files, tables or data
- Changing the structure of the database
- Publishing to your own domain
- Sending emails or text messages to real customers
- Installing new packages
- Using an API key for the first time

## Attachments

Drop files or links into the chat: screenshots, Figma links, PDFs, spreadsheets or the address of your current site. Appmake reads them and uses them in the next step, for example to match a layout or import rows into a table.

## Long conversations

A small ring next to the model name shows how much of the conversation Appmake can keep in mind at once. When it gets full, Appmake writes a summary of the project so far and continues from it. Nothing in your app is lost.

> Start a new chat for a big new feature. The project, its code and its history stay the same.

---

# Plan mode

Plan mode turns your idea into a plan with pages, data, integrations and a price, before any code is written.

Source: https://appmake.ai/docs/guides/plan-mode

## When to use it

Use plan mode for a new app, a new area of an app, payments, accounts or anything you want priced first. For small edits like text, colours or one new section, just ask in the chat.

| Use plan mode for | Just ask for |
|---|---|
| A new app or a new area | Text, colour and spacing |
| Payments, accounts or roles | One new section on a page |
| Changes to how data is stored | Fixing a typo or a link |
| Work that needs sign-off | Trying an idea you can undo |

## What a plan contains

- The pages and how they link together
- The database tables and their fields
- The services to connect, such as Stripe or Shopify
- Features Appmake suggests you may have forgotten, such as a cookie banner
- Costs outside Appmake, such as Shopify or text-message fees
- A credit estimate as a range

## Phases

Bigger apps are split into phases. A CRM, for example, starts with contacts, deals and tasks, then adds email and import, then teams and reports. The plan shows every phase with its own estimate.

You approve phase 1. When it is live, Appmake offers the next phase in the chat with **Build phase 2** and **Not now**. Phases you skip stay in the plan until you ask for them.

## Edit and approve

Click **Edit plan** to remove or add items. The estimate updates as you go. When the plan looks right, click **Approve and build**.

> Planning never uses credits. If a step turns out to need more than estimated, Appmake asks before it goes over.

## Share a plan for sign-off

Send a read-only link to a partner, client or manager. They can comment on any part, and you see when the plan is approved. Turn the link off at any time.

---

# Click to edit

Click any part of the preview and change it on the spot, or describe the change in words.

Source: https://appmake.ai/docs/guides/click-to-edit

## Select an element

Click the cursor icon above the preview, then click an element: a heading, a button, an image, a price or a whole section. An orange outline shows what is selected, with its name above it.

## Change it directly

Simple changes are quickest by hand. Edit the text, pick a colour from your palette, change the size, the spacing or the corners. Changes show in the preview at once.

For anything with judgement in it, type what you want in the box below the element, for example *make this stand out more, but not in red*. Appmake knows exactly which element you mean.

## One element or all of them

Appmake knows which elements share a style. Apply a change to this button only, or to every button on the site in one step.

## Screen sizes

Edits apply to every screen size by default. Switch the preview to tablet or phone to adjust one layout without touching the others.

## Undo

Every click edit is saved as a version, and written into the same code Appmake writes. Undo the last change, or restore any earlier version from the Versions tab.

---

# Agent testing

Before anything goes live, Appmake uses your app in a real browser, the way a customer would, and fixes what fails.

Source: https://appmake.ai/docs/guides/testing

## What gets tested

Appmake writes tests from your plan. A shop gets checkout tests, a booking site gets booking tests. Every run covers:

- Full flows such as sign up, book, buy and log out
- Forms, required fields and error messages
- Payments with Stripe test cards
- Phone, tablet and desktop layouts
- Links, images and slow pages
- Basic accessibility: contrast, labels and keyboard use

## Find, fix and prove

When a test fails, Appmake reads the error, fixes the code and runs the test again. You see each fix in the chat with the file and lines that changed.

If it cannot fix a problem on its own, it stops, shows you the error and asks how you want to continue.

## Nothing broken goes live

Publishing waits for the tests to pass. If a test fails, your live app keeps running the last version that passed.

## Ask for your own tests

Describe what must always work, in plain words. Appmake writes the test and runs it with every change from then on.

```text
Make sure sold-out classes can't be booked,
even if someone opens the booking link directly.
```

Tests are saved with your code in `tests/`, so a developer can run them with `npm test`.

---

# Projects and versions

Every change is saved as a version you can preview, compare and restore.

Source: https://appmake.ai/docs/guides/versions

## Projects

Each app is a project in your workspace. The Projects page shows every project with its status: **Live**, **Building**, **Waiting for you** or **Draft**. Star the ones you use most and switch between grid and list.

## Versions

Every change, by you, a teammate or Appmake, becomes a version with a short description of what changed. Open any version to see it running, compare two versions or restore one.

Restoring creates a new version, so you can always go back again. Your data is not affected: orders, bookings and customers stay when you restore the app.

## Checkpoints

Name the versions that matter, such as *Before launch* or *Client approved*, so you can find them later without scrolling.

## Export and GitHub

Download the code of any version as a zip file, or connect a GitHub repository you own. Each version becomes a commit with a clear message, and Appmake reads your own commits before it changes anything.

---

# Database

Every project has its own Postgres database. Appmake designs it from your description, and you can browse and edit it like a spreadsheet.

Source: https://appmake.ai/docs/platform/database

## How the database is set up

When you approve a plan, Appmake creates the tables your app needs, with the right fields and the links between them. A booking site gets classes, bookings and members. A shop gets products, orders and customers.

The database runs on **Postgres on Supabase**. It is standard Postgres, so it works with any tool that speaks Postgres.

## Browse and edit data

Open **Database** in the sidebar or the Database tab in the builder. Pick a table to see its rows. Click a cell to edit it, add rows, filter and sort. Changes show up in your app straight away.

## Change the structure by asking

Ask in the chat, for example *let customers add a gift message to their order*. Appmake writes a migration, keeps every existing row and updates the pages that use the table. Changes to the structure always wait for your approval.

```sql
alter table orders
  add column gift_message text;
```

## Import data

Drop a CSV or Excel file into the chat, or connect Shopify. Appmake matches the columns to your fields, converts values such as dates and yes/no, and shows you the mapping before it imports.

## Access rules

Rules for who can read and change each table are set on the database itself, so they hold on every page and in every request. Customers only ever see their own orders unless you decide otherwise.

## Backups and export

Appmake backs up every database automatically. To restore, open **Database → Backups**, pick a point in time and restore it, or copy it to a new project to look first. Restoring the database does not change your app's code.

Export a table or the whole database as CSV or SQL at any time. Developers can copy the connection string from **Database → Connect**.

---

# Domains and hosting

Every app runs in its own container with TLS switched on. Publish to a free appmake.ai address or connect a domain you own.

Source: https://appmake.ai/docs/platform/domains

## Your free address

When you publish for the first time, your app gets an address like `lotus-yoga.appmake.ai`. You can rename it in the project settings.

## Connect your own domain

1. **Add the domain** Open **Domains**, click **Add domain** and type the domain, for example `lotusyoga.dk`.
2. **Add three records at your registrar** An `A` record for the root, a `CNAME` for `www` and a `TXT` record that proves the domain is yours. Copy the values from Appmake.
3. **Wait for the check** Appmake checks the records for you. It usually takes a few minutes and can take up to a day.
4. **Go live** When the records are found, Appmake issues a certificate and your app is live on the domain.

| Type | Name | Value |
|---|---|---|
| A | @ | The IP address shown in Appmake |
| CNAME | www | `edge.appmake.ai` |
| TXT | _appmake | The verification code shown in Appmake |

> Using Cloudflare? Set the records to *DNS only* (grey cloud) until the domain shows as live.

## TLS

Certificates are issued and renewed automatically for the domain and `www`. Visitors on `http://` are sent to `https://`.

## Publishing without downtime

When you publish, the new version starts next to the old one and traffic switches only after the tests pass. The previous version is kept warm, so a rollback takes seconds.

Each change also gets a private preview address you can share before publishing.

## Settings and secrets

API keys and settings live per environment. Previews use test keys and the live app uses live keys. Keys are stored in an encrypted vault and are never shown in the chat or written into the code.

## Logs

Every request and error is logged per app. Ask Appmake about an error in the chat and get the cause and a suggested fix in plain words.

---

# Integrations

Connect the services your business runs on. Appmake sets up the connection, writes the code and tests it.

Source: https://appmake.ai/docs/platform/integrations

## Available integrations

| Service | What it does in your app |
|---|---|
| Shopify | Products, stock, cart and checkout in your own storefront |
| Stripe | Payments, subscriptions, receipts and refunds |
| Supabase | The Postgres database behind every app |
| Resend | Order confirmations, receipts and newsletters |
| Twilio | Text-message reminders and codes |
| Slack | New orders and bookings posted to a channel |
| Cloudinary | Image uploads, resizing and fast delivery |
| Google Analytics | Visitor and conversion tracking |
| Zapier | Connections to thousands of other apps |

Not listed? If a service has an API, ask Appmake to connect it. It reads the service's documentation, asks for your key and writes the integration.

## Connect a service

Open **Integrations** and click **Connect**, or let Appmake ask when the build needs it. You approve access on the service's own page, so Appmake never sees your password. Where a key is needed, it goes into the encrypted vault.

## Shopify storefronts

Keep running products, stock and orders in Shopify. Appmake builds the storefront around them with your own pages and design, and hands the cart over to Shopify's checkout. Host it on Appmake with your domain, or on Shopify Hydrogen and Oxygen.

## Stripe payments

Appmake builds and tests payments in Stripe test mode with test cards. Switch to live keys when you launch. Stripe charges its own fees.

## Disconnect

Each connection lists what it can read and change and when it was last used. Before you disconnect, Appmake shows which pages and automations use it.

---

# Appmake Cloud

Appmake Cloud is usage-based hosting for apps that need more than a standard container.

Source: https://appmake.ai/docs/platform/cloud

## What it covers

Appmake Cloud scales your app with its traffic. You pay for what the app uses, measured in four meters:

| Meter | Measured in |
|---|---|
| Compute | Hours of running time |
| Database | GB stored |
| Storage | GB of files and images |
| Bandwidth | GB sent to visitors |

The current rates are shown on the **Appmake Cloud** page in the app.

## How it is paid

Cloud usage is paid from your prepaid balance, the same balance Appmake uses when your plan's credits run out. Turn on auto-refill so your apps keep running when the balance gets low.

> Without auto-refill, Cloud apps pause when the balance reaches zero. Appmake emails you before that happens.

## Limits and alerts

Set a monthly limit per app and get an email when usage passes 50%, 80% and 100% of it. Usage per app and per meter is shown day by day.

---

# Marketing

Connect your social accounts, let Kalle by Appmake write posts from your apps and schedule them in one calendar.

Source: https://appmake.ai/docs/platform/marketing

## Connect accounts

Open **Marketing** and connect the accounts you post to. Instagram, Facebook, LinkedIn, X, TikTok, YouTube, Pinterest and Threads are supported, along with more than thirty other networks.

## Let Kalle by Appmake write posts

Click **Let Kalle write one**. Kalle by Appmake reads your app, for example a new product, a new class or a sale, and writes a post for each network in its own format and length. Edit the text and pick images or video before scheduling.

## Calendar and approval

Scheduled posts appear in the calendar. Drag a post to move it. Posts from members can wait for approval by an admin before they go out.

## Results

Each published post shows its reach and clicks, so you can see what works and ask Kalle by Appmake for more posts like it.

---

# Credits, billing and plans

Plans are billed yearly. Your plan includes credits every month, and a prepaid balance covers anything beyond them.

Source: https://appmake.ai/docs/platform/billing

## Plans

| Plan | Price | Credits included |
|---|---|---|
| Pro | €290 a year (about €24 a month) | 300 a month |
| Team | €1,190 per seat a year (about €99 a month) | 1,200 per seat a month, shared by the team |
| Enterprise | Contact sales | Custom volume |

Prices in US dollars are $319 for Pro and $1,309 per seat for Team. VAT is added where it applies. Enterprise adds SSO and SCIM, invoice billing, a custom number of seats, a dedicated contact person, an uptime SLA, data stored in the EU and an audit log.

> Every plan comes with a 60-day money-back guarantee. Students and non-profits can apply for 50% off.

## How credits work

Credits measure the work Appmake does. Planning is free. A small edit uses about one credit, a full first build uses more. The credits per step depend on the model and the effort:

| Model | Credits per step at Medium effort |
|---|---|
| Kalle Turbo | 1 |
| Kalle Design | 2 |
| Kalle Turbo Max | 2 |
| Kalle Turbo Ultra | 3 |

Plan credits refill on the 1st of each month and do not roll over. See [Effort](https://appmake.ai/docs/kalle/effort) for how effort changes the cost.

## Prepaid balance and auto-refill

When your plan's credits run out, Appmake keeps working from your prepaid balance. It works like a top-up card: add at least €10 and it is charged straight away. Work pauses when the balance is empty.

Turn on **auto-refill** to top up automatically. You choose the amount and the threshold, for example *add €25 when the balance is below €5*. You get a receipt by email each time.

## Renewal and failed payments

Your plan renews automatically each year. If a payment fails, Appmake tries again for 7 days. After that, building pauses, and your published apps stay online for 30 days while you update the card.

## Invoices

Invoices are in **Billing**. Add your company name, VAT number, country and billing email so invoices show the right details. Enterprise customers can pay by invoice.

---

# Teams, workspaces and roles

Invite people to work on your apps, give each person the right role, and keep clients or brands apart in separate workspaces.

Source: https://appmake.ai/docs/platform/teams

## Invite people

On the Team plan, open **Team** and click **Invite people**. Type one or more email addresses and pick a role. Each person gets an email with a link to join.

Pending invites hold a seat until they are accepted. Resend an invite, copy its link or withdraw it from the **Pending invites** list.

## Roles

| Role | Can do |
|---|---|
| Owner | Everything, including billing and deleting the workspace |
| Admin | Manage people, domains, integrations and approve posts |
| Member | Build and edit projects, publish to appmake.ai addresses |

## Workspaces

A workspace holds projects, people, domains, data and a plan. Create one per client, brand or team so nothing leaks between them. Switch workspace from the top of the sidebar.

## Single sign-on

On Enterprise, your team signs in with your identity provider using SAML 2.0, such as Okta, Microsoft Entra ID or Google Workspace. SCIM adds and removes people automatically. Set it up in **Settings → Single sign-on**.

---

# Agencies and partner programme

Run every client in its own workspace and earn commission on the clients you bring to Appmake.

Source: https://appmake.ai/docs/platform/agencies

## How agencies work in Appmake

Create a workspace per client with its own projects, domain, brand and people. Build a prototype in the first meeting, share the plan for sign-off and invite the client as a member when the app is ready.

## The partner programme

- **30% recurring commission** on every client you bring, for as long as the client stays
- **20% off Team seats** for your own staff
- A listing in the Appmake partner directory
- Priority support
- Client invoicing through Appmake

To join, [talk to sales](https://appmake.ai/solutions/agencies#talk-to-sales). We set up your partner area, where you see your clients, their plans and your commission each month.

## Hand over or keep running

Move a workspace to the client's own account when the project ends. The app, data and domain move with it, and you can stay on as a member. Or keep the workspace and look after the app as a monthly service.

---

# Security and privacy

How Appmake protects your account, your apps and your customers' data.

Source: https://appmake.ai/docs/platform/security

## Your data

- Appmake never trains AI models on your projects, your data or your customers' data.
- Data is stored in the EU.
- Data is encrypted in transit and at rest.
- We sign a GDPR data processing agreement with you on request.
- Ask us to delete your data, and it is deleted within 30 days.

## Protect your account

In **Settings → Security** you can turn on two-factor authentication with an authenticator app, add passkeys, get an email when someone signs in from a new device, and sign out sessions you don't recognise.

## Keys and secrets

API keys you give Appmake are stored in an encrypted vault per workspace. They are never shown in the chat, written into the code or included in exports. Kalle Browser never sees your passwords: sign-in pages are handed back to you.

## Audit log

On Enterprise, every sign-in, change, invite, payment and key is recorded in the audit log for a year. Export it as CSV or stream it to your SIEM.

## Report a problem

Found a security issue? Email `security@appmake.ai`. We reply within two working days.

---

# Troubleshooting and FAQ

Answers to the questions we get most, and what to do when something doesn't work.

Source: https://appmake.ai/docs/platform/troubleshooting

## Appmake stopped building

Building pauses when your plan credits and your prepaid balance are both used up. Add to your balance in **Credits** or turn on auto-refill, then press **Continue** in the chat.

## My domain isn't live

- Check that the `A`, `CNAME` and `TXT` records match the values in Appmake exactly.
- Remove old `A` or `AAAA` records for the same name.
- If you use Cloudflare, set the records to *DNS only*.
- Records can take up to a day to spread. Appmake keeps checking.

## A test keeps failing

Appmake tries to fix failing tests on its own. If it can't, it shows you the error and asks how to continue. Your live app keeps running the last version that passed. You can ask Appmake to explain the error in plain words.

## Emails don't arrive

Check the spam folder first. To send from your own domain, verify the domain in Resend and add its DNS records. Until then, emails are sent from an Appmake address.

## Frequently asked questions

| Question | Answer |
|---|---|
| Is there a free plan? | No. Plans are yearly, with a 60-day money-back guarantee. |
| Do I own the code? | Yes. Export it or sync it to GitHub at any time. |
| Can I use my own domain? | Yes, on every plan. |
| Can I cancel? | Yes. Your plan runs until the end of the year you paid for. Within 60 days you get your money back. |
| Which languages can I write in? | Any. Kalle by Appmake answers in the language you write in. |

## Still stuck?

Ask Kalle by Appmake in the chat inside the app, or email `support@appmake.ai`. Team and Enterprise customers get priority support.

---

# Kalle by Appmake

Kalle by Appmake is Appmake's own family of AI models. It does the work in the builder, in Kalle Browser and through the API.

Source: https://appmake.ai/docs/kalle/overview

## What it does

In the builder, Kalle by Appmake asks questions, writes the plan, writes the code, runs the tests and explains each step. In Kalle Browser it does tasks on the web for you. Through the [Kalle by Appmake API](https://appmake.ai/docs/api/kalle/overview) you can use the same models in your own products.

It answers in the language you write in, keeps the context of your project and asks before anything that costs money or changes real data.

## The model family

| Model | Best for | Credits per step |
|---|---|---|
| Kalle Turbo | Small, clear edits in seconds | 1 |
| Kalle Design | Layouts, typography and visual polish | 2 |
| Kalle Turbo Max | Full builds and new features | 2 |
| Kalle Turbo Ultra | The biggest jobs and the hardest bugs | 3 |

**Auto** picks the model for each step. Read more in [Models](https://appmake.ai/docs/kalle/models).

## Your data

- Kalle by Appmake never trains on your projects, your data or your customers' data.
- Data is stored in the EU and encrypted in transit and at rest.
- Kalle Browser never sees your passwords.

---

# Models

Four models, each tuned for a kind of work. Leave the builder on Auto, or pick one yourself in the composer.

Source: https://appmake.ai/docs/kalle/models

## Auto

Auto looks at each step and picks the model and effort for it. A typo goes to Kalle Turbo at low effort. A redesign goes to Kalle Design. A hard bug goes to Kalle Turbo Ultra. This keeps your credits for the work that needs them.

## Compare the models

|  | Kalle Turbo | Kalle Design | Kalle Turbo Max | Kalle Turbo Ultra |
|---|---|---|---|---|
| Best for | Quick edits | Design and polish | Full builds | Hardest problems |
| Credits per step | 1 | 2 | 2 | 3 |
| Effort levels | Low to High | Low to Extra | Low to Extra | Medium to Max |
| Default effort | Low | Medium | Medium | High |
| API ID | `kalle-turbo` | `kalle-design` | `kalle-turbo-max` | `kalle-turbo-ultra` |

## Which one should I pick?

- **Changing text, colours or one small thing:** Kalle Turbo.
- **Making it look better, a new layout, a style:** Kalle Design.
- **A new feature, a new page with data, a first build:** Kalle Turbo Max.
- **Something is broken and the other models couldn't fix it:** Kalle Turbo Ultra.

> Not sure? Use Auto. You can see which model was used for each step in the change summary.

---

# Effort

Effort sets how long Kalle by Appmake thinks and how much it checks its work before it answers.

Source: https://appmake.ai/docs/kalle/effort

## The levels

| Level | What it does | Credits per step |
|---|---|---|
| Auto | Picks the effort for each step | Varies |
| Low | Answers fast. Good for text, colour and small fixes. | ½× |
| Medium | Thinks before it builds. Right for most work. | 1× |
| High | Plans in more detail and checks its work twice. | 1.5× |
| Extra | Tries several approaches before it picks one. | 2× |
| Max | Thinks as long as it needs, for the hardest problems. | 3× or more |

## Which models support which levels

Kalle Turbo goes up to High. Kalle Design and Kalle Turbo Max go up to Extra. Kalle Turbo Ultra goes from Medium to Max. Levels a model can't use are shown greyed out in the picker.

## Use Max with care

> Max can use three times the credits of Medium, or more. Use it for problems the other levels couldn't solve, not as a default.

---

# Kalle Browser

Kalle Browser is a browser extension that does tasks on the web for you, in your own browser.

Source: https://appmake.ai/docs/kalle/browser

## Install

Kalle Browser works in Chrome, Edge, Brave, Arc, Firefox and Safari. Open **Kalle Browser** in Appmake and click **Install** next to your browser. Sign in once with your Appmake account.

## Give it a task

Describe the task: *reorder 20 yoga mats from our supplier*, *fill in the VAT form with last month's numbers*, *find three venues for 40 people in Aarhus*. Kalle Browser opens the pages, reads them and does the steps while you watch.

## It asks before it pays or sends

Kalle Browser stops and asks before it pays for anything, submits a form, sends a message or deletes something. You see exactly what it is about to do and choose **Approve** or **Stop**.

- It never sees your passwords. Sign-in pages are handed back to you.
- It only works in tabs you give it.
- Every task is logged in Appmake with each step.

## What it costs

Browser tasks use credits like everything else. A short lookup uses a few credits. A long task with many pages uses more. You can see the credits for each task in the task list.

---

# Getting good results

Kalle by Appmake works best when it knows who the app is for and what must happen. These habits help.

Source: https://appmake.ai/docs/kalle/prompting

## Say who it's for and what must happen

*A booking site* is a start. *A booking site where members of my yoga studio book classes with a 10-class pass* is a plan. Mention the people, the main action and anything that must never go wrong.

## Show, don't only tell

Paste a link to a site you like, a screenshot or a Figma frame. It is the fastest way to get the look right.

## Small changes in chat, big ones in plan mode

Ask for one change at a time when you are fine-tuning. For a new area of the app, use plan mode so you can see the scope and price first.

## Say what must not change

```text
Make the homepage feel more premium,
but keep the booking flow exactly as it is.
```

## Ask why

If you don't understand a step, ask *why did you do that?* Kalle by Appmake explains its reasoning in plain words and can undo the step if you prefer.

---

# Kalle by Appmake API

Use Kalle by Appmake in your own products. Send a message, get an answer. Your first call takes about two minutes.

Source: https://appmake.ai/docs/api/kalle/overview

## 1. Get an API key

Sign in to Appmake and open **Kalle API** in the sidebar. Click **Create key**, give it a name and copy it. Keys start with `kalle_sk_`.

```bash
export KALLE_API_KEY="kalle_sk_live_..."
```

> Keep keys on your server. Never put a key in front-end code or a public repository.

## 2. Install the SDK

Pick your language. The SDKs read `KALLE_API_KEY` from the environment. You can also call the API directly with cURL.

| Language | Install |
|---|---|
| TypeScript | `npm install kalle` |
| Python | `pip install kalle` |
| Go | `go get github.com/appmake/kalle-go` |
| Ruby | `gem install kalle` |
| PHP | `composer require kalle/kalle-php` |
| Java | `build.kalle:kalle-java:1.0.0` |

## 3. Send your first message

This sends one message to **Kalle Turbo** and prints the answer. The reply text is in `content[0].text`.

Press **Try it** next to the code to send it from this page with a test key.

```bash
curl https://api.kalle.build/v1/messages \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kalle-turbo",
    "max_tokens": 256,
    "messages": [
      {
        "role": "user",
        "content": "Hello, Kalle"
      }
    ]
  }'
```

Response:

```json
{
  "id": "msg_01HQ7c9vK2",
  "type": "message",
  "role": "assistant",
  "model": "kalle-turbo-2026-11-01",
  "content": [
    {
      "type": "text",
      "text": "Hello! What would you like to build today?"
    }
  ],
  "stop_reason": "end_turn",
  "usage": {
    "input_tokens": 9,
    "output_tokens": 11
  }
}
```

## Next steps

- [Messages](https://appmake.ai/docs/api/kalle/messages): All parameters, roles and the response object.
- [Streaming](https://appmake.ai/docs/api/kalle/streaming): Show the answer while it is written.
- [Tool use](https://appmake.ai/docs/api/kalle/tools): Let Kalle by Appmake call your functions.
- [Platform API](https://appmake.ai/docs/api/platform/overview): Create projects and publish apps from code.

---

# Authentication and API keys

Every request is signed with a secret key from your workspace. One key works for both the Kalle by Appmake API and the Platform API.

Source: https://appmake.ai/docs/api/kalle/auth

## Sending your key

Send the key in the `Authorization` header as a bearer token, and the API version in `Kalle-Version`. All requests use HTTPS against `https://api.kalle.build/v1`.

```http
Authorization: Bearer kalle_sk_live_...
Kalle-Version: 2026-11-01
Content-Type: application/json
```

```bash
curl https://api.kalle.build/v1/models \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01"
```

## Creating and managing keys

Create keys in Appmake under **Kalle API**. A key belongs to a workspace, and its usage is billed to that workspace's prepaid balance. You can see when each key was last used.

- Give each server or app its own key, so you can turn one off without touching the others.
- Restrict a key to the scopes it needs: `messages`, `files`, `browser`, `platform:read`, `platform:write`.
- Rotate a key by creating a new one, deploying it and then deleting the old one.

## If a key leaks

Delete the key in Appmake straight away. Deleted keys stop working within seconds. If we find one of your keys in a public GitHub repository, we disable it and email the workspace owners.

---

# SDKs

Official libraries for seven languages. `kalle` is for the models; `appmake` is for the platform.

Source: https://appmake.ai/docs/api/kalle/sdks

## Packages

| Language | Kalle by Appmake API | Platform API |
|---|---|---|
| TypeScript | `npm install kalle` | `npm install appmake` |
| Python | `pip install kalle` | `pip install appmake` |
| Go | `github.com/appmake/kalle-go` | `github.com/appmake/appmake-go` |
| Ruby | `gem install kalle` | `gem install appmake` |
| PHP | `kalle/kalle-php` | `appmake/appmake-php` |
| Java | `build.kalle:kalle-java` | `ai.appmake:appmake-java` |

Both packages read the same `KALLE_API_KEY` environment variable.

## What the SDKs handle for you

- Retries with backoff on `429` and `5xx` errors, two times by default
- Streaming helpers that give you the text as it arrives
- Typed request and response objects
- Pagination helpers for list endpoints
- The `Kalle-Version` header, pinned to the version the SDK was released for

---

# Versions

The API is versioned by date, and models have pinned snapshots. Your integration only changes when you choose.

Source: https://appmake.ai/docs/api/kalle/versioning

## API versions

Send `Kalle-Version` with every request. The current version is `2026-11-01`. Requests without the header use the version that was current when your key was created.

| Version | Status | What changed |
|---|---|---|
| `2026-11-01` | Current | Parallel tool calls, `count_tokens`, Max effort on Kalle Turbo Ultra |
| `2026-09-15` | Supported | First public version |

## Model aliases and snapshots

`kalle-turbo-max` is an alias that points to the newest snapshot. To keep behaviour fixed, use the dated snapshot instead, for example `kalle-turbo-max-2026-11-01`. The response always says which snapshot answered.

## Deprecations

We announce deprecations in the [changelog](https://appmake.ai/docs/changelog) and by email to workspace owners at least six months before a version or snapshot stops working.

---

# Models

List the models your key can use, with their limits.

Source: https://appmake.ai/docs/api/kalle/models

## List models

| Model ID | Context window | Max output | Effort |
|---|---|---|---|
| `kalle-turbo` | 200K tokens | 16K tokens | low, medium, high |
| `kalle-design` | 200K tokens | 32K tokens | low to extra |
| `kalle-turbo-max` | 400K tokens | 64K tokens | low to extra |
| `kalle-turbo-ultra` | 1M tokens | 128K tokens | medium to max |

```bash
curl https://api.kalle.build/v1/models \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01"
```

Response:

```json
{
  "data": [
    {
      "id": "kalle-turbo",
      "snapshot": "kalle-turbo-2026-11-01",
      "display_name": "Kalle Turbo",
      "context_window": 200000,
      "max_output_tokens": 16000
    },
    {
      "id": "kalle-design",
      "snapshot": "kalle-design-2026-11-01",
      "display_name": "Kalle Design",
      "context_window": 200000,
      "max_output_tokens": 32000
    },
    {
      "id": "kalle-turbo-max",
      "snapshot": "kalle-turbo-max-2026-11-01",
      "display_name": "Kalle Turbo Max",
      "context_window": 400000,
      "max_output_tokens": 64000
    },
    {
      "id": "kalle-turbo-ultra",
      "snapshot": "kalle-turbo-ultra-2026-11-01",
      "display_name": "Kalle Turbo Ultra",
      "context_window": 1000000,
      "max_output_tokens": 128000
    }
  ],
  "has_more": false
}
```

## Get a model

Returns one model by ID or snapshot name. Useful to check the limits before you send a large request.

```bash
curl https://api.kalle.build/v1/models/kalle-design \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01"
```

---

# Messages

Send a conversation and get Kalle by Appmake's next message.

Source: https://appmake.ai/docs/api/kalle/messages

## Create a message

- `model` (string, required): The model ID or snapshot, for example `kalle-turbo-max`.
- `messages` (array, required): The conversation so far. Each item has a `role` (`user` or `assistant`) and `content`, a string or a list of content blocks.
- `max_tokens` (integer, required): The most tokens the reply may use. The model may stop earlier.
- `system` (string): Instructions for the whole conversation, such as tone or rules.
- `effort` (string): `low`, `medium`, `high`, `extra` or `max`. Defaults to the model's recommended effort. See [Effort](https://appmake.ai/docs/kalle/effort).
- `temperature` (number): From 0 to 1. Lower gives more predictable wording. Default 0.7.
- `stream` (boolean): Send the reply as server-sent events. See [Streaming](https://appmake.ai/docs/api/kalle/streaming).
- `tools` (array): Functions the model may ask you to run. See [Tool use](https://appmake.ai/docs/api/kalle/tools).
- `metadata` (object): Your own `user_id` for abuse monitoring. Not used for training.

```bash
curl https://api.kalle.build/v1/messages \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kalle-turbo-max",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Write a short welcome text for a yoga studio in Copenhagen."
      }
    ]
  }'
```

Response:

```json
{
  "id": "msg_01HQ7c9vK2",
  "type": "message",
  "role": "assistant",
  "model": "kalle-turbo-max-2026-11-01",
  "content": [
    {
      "type": "text",
      "text": "Welcome to Lotus Yoga. Step off the street in Nørrebro and into a calm, warm room where every class starts where you are."
    }
  ],
  "stop_reason": "end_turn",
  "usage": {
    "input_tokens": 24,
    "output_tokens": 31
  }
}
```

## The response

- `id` (string): The message ID, starting with `msg_`.
- `content` (array): Content blocks. Text is in blocks with `type: "text"`. Tool calls are in blocks with `type: "tool_use"`.
- `stop_reason` (string): `end_turn`, `max_tokens`, `tool_use` or `stop_sequence`.
- `usage` (object): `input_tokens` and `output_tokens` for billing.

## Multi-turn conversations

The API keeps no memory between calls. To continue a conversation, send the earlier messages again with the new one at the end, alternating `user` and `assistant`.

```json
"messages": [
  { "role": "user", "content": "Suggest a name for my yoga studio." },
  { "role": "assistant", "content": "How about Lotus Yoga?" },
  { "role": "user", "content": "Something warmer, please." }
]
```

---

# Streaming

Get the reply piece by piece as it is written, so people see the answer straight away.

Source: https://appmake.ai/docs/api/kalle/streaming

## Stream a message

Set `stream` to `true`. The response is a stream of server-sent events. The SDKs give you a helper that yields the text as it arrives.

```bash
curl https://api.kalle.build/v1/messages --no-buffer \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kalle-turbo-max",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Write a short welcome text for a yoga studio in Copenhagen."
      }
    ],
    "stream": true
  }'
```

## Event types

| Event | When |
|---|---|
| `message_start` | Once, with the message ID and model |
| `content_block_start` | When a text or tool block starts |
| `content_block_delta` | Each new piece of text, in `delta.text` |
| `content_block_stop` | When a block is finished |
| `message_delta` | At the end, with `stop_reason` and final `usage` |
| `message_stop` | The last event |
| `ping` | Sent every 15 seconds to keep the connection open |

```text
event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Welcome to "}}

event: message_stop
data: {"type":"message_stop"}
```

## Errors during a stream

If something goes wrong after the stream has started, you get an `error` event with the same shape as a normal [error](https://appmake.ai/docs/api/kalle/errors), and the stream ends.

---

# Tool use

Describe your functions, and Kalle by Appmake asks you to run them when it needs data or wants to act.

Source: https://appmake.ai/docs/api/kalle/tools

## Define a tool

Each tool has a `name`, a `description` that explains when to use it, and an `input_schema` in JSON Schema. Clear descriptions give better results.

```bash
curl https://api.kalle.build/v1/messages \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kalle-turbo-max",
    "max_tokens": 1024,
    "tools": [
      {
        "name": "get_schedule",
        "description": "Get the class schedule for one day.",
        "input_schema": {
          "type": "object",
          "properties": {
            "date": {
              "type": "string",
              "description": "The date as YYYY-MM-DD"
            }
          },
          "required": [
            "date"
          ]
        }
      }
    ],
    "messages": [
      {
        "role": "user",
        "content": "Which classes are on Friday?"
      }
    ]
  }'
```

Response:

```json
{
  "id": "msg_01HQ8a4T",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Let me check Friday's schedule."
    },
    {
      "type": "tool_use",
      "id": "tool_9fK2",
      "name": "get_schedule",
      "input": {
        "date": "2026-11-13"
      }
    }
  ],
  "stop_reason": "tool_use",
  "usage": {
    "input_tokens": 182,
    "output_tokens": 41
  }
}
```

## Run the tool and reply

1. **Kalle by Appmake asks** The response has `stop_reason: "tool_use"` and a `tool_use` block with the tool's `name`, an `id` and the `input`.
2. **You run it** Call your own function with the input.
3. **You send the result** Send the conversation again, with the assistant message and a new `user` message containing a `tool_result` block with the same `id`.
4. **Kalle by Appmake answers** It uses the result in its reply, or asks for another tool.

```json
{
  "role": "user",
  "content": [{
    "type": "tool_result",
    "tool_use_id": "tool_9fK2",
    "content": "07:00 Morning flow, 12:15 Lunch yoga, 18:00 Yin"
  }]
}
```

## Controlling tool use

- `tool_choice` (object): `{"type": "auto"}` lets the model decide (default). `{"type": "any"}` requires a tool. `{"type": "tool", "name": "get_schedule"}` requires that tool. `{"type": "none"}` turns tools off.

Kalle by Appmake can ask for several tools in one reply. Run them all and send all the results in one message.

---

# Files and images

Send images and documents with your messages, by URL or by uploading them first.

Source: https://appmake.ai/docs/api/kalle/files

## Upload a file

Upload once and refer to the file by its ID in as many messages as you like. Files are stored until you delete them and are only visible to your workspace.

| Type | Formats | Max size |
|---|---|---|
| Images | JPEG, PNG, WebP, GIF | 10 MB |
| Documents | PDF, plain text, Markdown, CSV | 32 MB |

```bash
curl https://api.kalle.build/v1/files \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01" \
  -F "file=@menu.pdf" \
  -F "purpose=user_data"
```

Response:

```json
{
  "id": "file_9Kd2",
  "filename": "menu.pdf",
  "bytes": 182344,
  "mime_type": "application/pdf",
  "created_at": "2026-11-05T09:12:44Z"
}
```

## Use files in a message

```json
"content": [
  { "type": "document", "source": { "type": "file", "file_id": "file_9Kd2" } },
  { "type": "image", "source": { "type": "url", "url": "https://example.com/studio.jpg" } },
  { "type": "text", "text": "Make a price list from the menu, in the style of the photo." }
]
```

## Delete a file

Deleted files can no longer be used in new messages.

```bash
curl https://api.kalle.build/v1/files/file_9Kd2 \
  -X DELETE \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01"
```

Response:

```json
{
  "id": "file_9Kd2",
  "deleted": true
}
```

---

# Kalle Browser tasks

Give Kalle Browser a task on the web and follow it step by step. It asks before it pays, sends or deletes anything.

Source: https://appmake.ai/docs/api/kalle/browser-tasks

## Start a task

- `task` (string, required): What the browser should do, in plain words.
- `start_url` (string): The page to start on.
- `require_approval` (array): Actions that wait for your approval: `payment`, `form_submit`, `message_send`, `delete`. All four by default.
- `webhook_url` (string): Where to send `browser.task.*` events instead of polling.

```bash
curl https://api.kalle.build/v1/browser/tasks \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01" \
  -H "Content-Type: application/json" \
  -d '{
    "task": "Find three venues in Aarhus for 40 people on 12 December and list their prices",
    "start_url": "https://www.google.com",
    "require_approval": [
      "payment",
      "form_submit",
      "message_send"
    ]
  }'
```

Response:

```json
{
  "id": "btk_4Rz8",
  "status": "running",
  "task": "Find three venues in Aarhus for 40 people on 12 December and list their prices",
  "steps": [],
  "credits_used": 0,
  "created_at": "2026-11-05T10:02:11Z"
}
```

## Follow the task

| Status | Meaning |
|---|---|
| `running` | Working through the steps |
| `requires_action` | Waiting for your approval, see `pending_action` |
| `completed` | Done. The result is in `output` |
| `failed` | Stopped. The reason is in `error` |
| `cancelled` | You stopped it |

```bash
curl https://api.kalle.build/v1/browser/tasks/btk_4Rz8 \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01"
```

Response:

```json
{
  "id": "btk_4Rz8",
  "status": "requires_action",
  "steps": [
    {
      "n": 1,
      "text": "Searched for venues in Aarhus"
    },
    {
      "n": 2,
      "text": "Opened three venue pages"
    }
  ],
  "pending_action": {
    "type": "form_submit",
    "description": "Send an enquiry form to Godsbanen for 12 December"
  }
}
```

## Approve or stop

Approve the pending action, or call `/cancel` to stop the task. Sign-in pages are never filled in by Kalle Browser: the task returns `requires_action` with type `sign_in` and a link for a person to sign in.

```bash
curl https://api.kalle.build/v1/browser/tasks/btk_4Rz8/approve \
  -X POST \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01"
```

Response:

```json
{
  "id": "btk_4Rz8",
  "status": "running"
}
```

---

# Count tokens

Find out how many input tokens a request will use before you send it.

Source: https://appmake.ai/docs/api/kalle/count-tokens

## Count tokens

Takes the same `model`, `messages`, `system` and `tools` as [Create a message](https://appmake.ai/docs/api/kalle/messages) and returns `input_tokens`. Counting is free and does not count towards rate limits.

```bash
curl https://api.kalle.build/v1/messages/count_tokens \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kalle-turbo-max",
    "messages": [
      {
        "role": "user",
        "content": "Write a short welcome text for a yoga studio in Copenhagen."
      }
    ]
  }'
```

Response:

```json
{
  "input_tokens": 24
}
```

---

# Errors

Errors use standard HTTP status codes and a JSON body that says what went wrong.

Source: https://appmake.ai/docs/api/kalle/errors

## Error shape

```json
{
  "type": "error",
  "error": {
    "type": "invalid_request_error",
    "message": "max_tokens: must be at least 1"
  },
  "request_id": "req_7f3KxQ2m"
}
```

Every response has a `request-id` header. Include it when you contact support.

## Error types

| Status | Type | What to do |
|---|---|---|
| 400 | `invalid_request_error` | Fix the request. The message says which field. |
| 401 | `authentication_error` | Check the key and the `Authorization` header. |
| 403 | `permission_error` | The key lacks the scope, or the balance is empty. |
| 404 | `not_found_error` | Check the ID or the model name. |
| 409 | `conflict_error` | The resource changed. Fetch it again and retry. |
| 413 | `request_too_large` | Send less, or upload files first. |
| 429 | `rate_limit_error` | Wait for `retry-after` seconds, then retry. |
| 500 | `api_error` | Retry with backoff. |
| 529 | `overloaded_error` | Retry with backoff, or use another model. |

## Retrying

Retry `429`, `500` and `529` with exponential backoff, starting at one second. The SDKs do this for you. Send an `Idempotency-Key` header on `POST` requests so a retry never creates something twice.

---

# Rate limits

Limits protect the service and grow automatically as your workspace uses the API.

Source: https://appmake.ai/docs/api/kalle/rate-limits

## Usage tiers

| Tier | Reached when | Requests per minute | Input tokens per minute | Output tokens per minute |
|---|---|---|---|---|
| 1 | First top-up of €10 | 50 | 40,000 | 8,000 |
| 2 | €100 spent | 1,000 | 400,000 | 80,000 |
| 3 | €500 spent | 2,000 | 1,000,000 | 200,000 |
| 4 | €1,000 spent | 4,000 | 4,000,000 | 800,000 |
| Enterprise | By agreement | Custom | Custom | Custom |

Your current tier is shown in Appmake under **Kalle API → Limits**.

## Rate limit headers

| Header | Meaning |
|---|---|
| `kalle-ratelimit-requests-remaining` | Requests left in the current minute |
| `kalle-ratelimit-tokens-remaining` | Tokens left in the current minute |
| `kalle-ratelimit-reset` | When the limit resets, as an RFC 3339 time |
| `retry-after` | Seconds to wait after a `429` |

---

# Pricing

The API is billed per token and paid from your workspace's prepaid balance.

Source: https://appmake.ai/docs/api/kalle/pricing

## Prices per million tokens

| Model | Input | Output |
|---|---|---|
| Kalle Turbo | $0.05 | $0.25 |
| Kalle Design | $1 | $5 |
| Kalle Turbo Max | $1 | $5 |
| Kalle Turbo Ultra | $2 | $10 |

Higher effort makes the model write more reasoning tokens, which are billed as output. Kalle Browser tasks are billed by the tokens they use. Counting tokens is free.

## Estimate your cost

## Platform API

Platform API calls are free. Work they start, such as a build from a [project message](https://appmake.ai/docs/api/platform/messages), uses credits from the workspace like the same work in the builder.

---

# Platform API

Create projects, ask Kalle by Appmake to change them, publish, connect domains, read data and get webhooks, all from your own code.

Source: https://appmake.ai/docs/api/platform/overview

## Basics

The Platform API uses the same base URL, keys and version header as the [Kalle by Appmake API](https://appmake.ai/docs/api/kalle/auth). Keys need the `platform:read` scope to read and `platform:write` to change anything.

| Object | ID prefix |
|---|---|
| Project | `prj_` |
| Project message | `pmsg_` |
| Deployment | `dpl_` |
| Domain | `dom_` |
| Webhook | `whk_` |
| Event | `evt_` |

```bash
curl https://api.kalle.build/v1/projects \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01"
```

Response:

```json
{
  "data": [
    {
      "id": "prj_8Hq2c",
      "name": "Lotus Yoga",
      "status": "live",
      "url": "https://lotusyoga.dk"
    }
  ],
  "has_more": false
}
```

## Pagination

List endpoints return up to `limit` items (default 20, max 100) and `has_more`. To get the next page, pass the last ID as `starting_after`. The SDKs can loop through all pages for you.

## Idempotency

Send an `Idempotency-Key` header with any `POST`. If the same key is sent again within 24 hours, you get the first response back instead of a second project or deployment.

---

# Projects

A project is one app: its code, versions, database and addresses.

Source: https://appmake.ai/docs/api/platform/projects

## Create a project

- `name` (string, required): The project name.
- `prompt` (string): What to build. Kalle by Appmake starts planning straight away.
- `template` (string): A starting point: `shop`, `shopify`, `crm`, `bookings`, `saas`, `dashboard`, `portal` and more.
- `plan_mode` (boolean): Wait for approval of the plan before building. Default `true`.

```bash
curl https://api.kalle.build/v1/projects \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Lotus Yoga",
    "prompt": "A booking site for my yoga studio with 10-class passes and reminder emails",
    "template": "bookings",
    "plan_mode": true
  }'
```

Response:

```json
{
  "id": "prj_8Hq2c",
  "name": "Lotus Yoga",
  "status": "planning",
  "url": null,
  "created_at": "2026-11-05T09:40:00Z"
}
```

## List and get projects

`GET /projects` lists projects in the workspace. `GET /projects/{id}` returns one project with its status, live address, latest version and credits used.

| Status | Meaning |
|---|---|
| `planning` | Kalle by Appmake is asking questions or writing the plan |
| `awaiting_approval` | A plan or action waits for approval |
| `building` | Work in progress |
| `live` | Published |
| `paused` | Out of credits and balance |

```bash
curl https://api.kalle.build/v1/projects/prj_8Hq2c \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01"
```

Response:

```json
{
  "id": "prj_8Hq2c",
  "name": "Lotus Yoga",
  "status": "live",
  "url": "https://lotusyoga.dk",
  "version": 14,
  "credits_used": 186
}
```

## Rename or delete

`PATCH /projects/{id}` changes the name. `DELETE /projects/{id}` deletes the project, its versions and its database. Deleting requires the `platform:write` scope and cannot be undone.

```bash
curl https://api.kalle.build/v1/projects/prj_8Hq2c \
  -X DELETE \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01"
```

Response:

```json
{
  "id": "prj_8Hq2c",
  "deleted": true
}
```

---

# Project messages

Ask Kalle by Appmake to change a project, the same way you would in the builder chat.

Source: https://appmake.ai/docs/api/platform/messages

## Send a message

- `content` (string, required): What to change, in plain words.
- `model` (string): `auto` (default) or a Kalle by Appmake model ID.
- `effort` (string): `auto` (default) or an effort level.
- `auto_approve` (boolean): Skip the approval step for changes under 20 credits. Default `false`.

Work uses credits from the workspace. Actions that always need a person, such as deleting data or sending email to real customers, still wait for approval in Appmake.

```bash
curl https://api.kalle.build/v1/projects/prj_8Hq2c/messages \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Add a waitlist when a class is full",
    "model": "auto",
    "effort": "auto"
  }'
```

Response:

```json
{
  "id": "pmsg_3Lw9",
  "status": "awaiting_approval",
  "plan": {
    "items": [
      "Waitlist table linked to classes",
      "Join button on full classes",
      "Email when a spot opens"
    ],
    "credits_estimate": {
      "low": 4,
      "high": 6
    }
  }
}
```

## Approve the plan

When the work is done, the message status becomes `completed` with a `summary` and the new `version`. Subscribe to `project.message.completed` to know when.

```bash
curl https://api.kalle.build/v1/projects/prj_8Hq2c/messages/pmsg_3Lw9/approve \
  -X POST \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01"
```

Response:

```json
{
  "id": "pmsg_3Lw9",
  "status": "running"
}
```

---

# Deployments

Publish a version, follow the build and roll back.

Source: https://appmake.ai/docs/api/platform/deployments

## Publish a version

Leave out `version` to publish the newest one. The deployment goes through `building`, `testing` and `live`. If a test fails, it ends as `failed` and the previous version stays live.

```bash
curl https://api.kalle.build/v1/projects/prj_8Hq2c/deployments \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01" \
  -H "Content-Type: application/json" \
  -d '{
    "version": 14
  }'
```

Response:

```json
{
  "id": "dpl_2Vx7",
  "status": "building",
  "version": 14,
  "url": "https://lotusyoga.dk",
  "created_at": "2026-11-05T11:20:03Z"
}
```

## Roll back

Puts the previous live version back in a few seconds and records it as a new deployment.

```bash
curl https://api.kalle.build/v1/deployments/dpl_2Vx7/rollback \
  -X POST \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01"
```

Response:

```json
{
  "id": "dpl_2Vy1",
  "status": "live",
  "version": 13,
  "rolled_back_from": "dpl_2Vx7"
}
```

---

# Domains

Connect a domain to a project and check its DNS records.

Source: https://appmake.ai/docs/api/platform/domains

## Add a domain

The response lists the DNS records to add at the registrar. Show them to your user, or add them yourself through your registrar's API.

```bash
curl https://api.kalle.build/v1/domains \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01" \
  -H "Content-Type: application/json" \
  -d '{
    "domain": "lotusyoga.dk",
    "project_id": "prj_8Hq2c"
  }'
```

Response:

```json
{
  "id": "dom_5Tq1",
  "domain": "lotusyoga.dk",
  "status": "pending",
  "records": [
    {
      "type": "A",
      "name": "@",
      "value": "76.76.21.21"
    },
    {
      "type": "CNAME",
      "name": "www",
      "value": "edge.appmake.ai"
    },
    {
      "type": "TXT",
      "name": "_appmake",
      "value": "am-verify=8f3k2q"
    }
  ]
}
```

## Check the records

Appmake checks domains on its own every few minutes. Call verify to check right away. Subscribe to `domain.verified` to hear when it goes live.

```bash
curl https://api.kalle.build/v1/domains/dom_5Tq1/verify \
  -X POST \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01"
```

Response:

```json
{
  "id": "dom_5Tq1",
  "status": "live",
  "tls": "active"
}
```

---

# Database

Read the tables and rows of a project's database.

Source: https://appmake.ai/docs/api/platform/database

## List tables

Returns each table with its columns and row count.

```bash
curl https://api.kalle.build/v1/projects/prj_8Hq2c/database/tables \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01"
```

Response:

```json
{
  "data": [
    {
      "name": "classes",
      "rows": 64
    },
    {
      "name": "bookings",
      "rows": 412
    },
    {
      "name": "members",
      "rows": 188
    }
  ]
}
```

## Run a query

Queries are read-only by default. To change data, add `"allow_write": true` and use a key with `platform:write`. Use `params` for values instead of building SQL strings.

```bash
curl https://api.kalle.build/v1/projects/prj_8Hq2c/database/query \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01" \
  -H "Content-Type: application/json" \
  -d '{
    "sql": "select name, starts_at from classes where starts_at > now() order by starts_at limit 5"
  }'
```

Response:

```json
{
  "rows": [
    {
      "name": "Morning flow",
      "starts_at": "2026-11-06T07:00:00Z"
    }
  ],
  "row_count": 1
}
```

---

# Webhooks

Get an HTTPS request when something happens in your workspace.

Source: https://appmake.ai/docs/api/platform/webhooks

## Create a webhook

Copy the `secret` from the response. It is only shown once and is used to check that requests come from Appmake.

```bash
curl https://api.kalle.build/v1/webhooks \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/appmake",
    "events": [
      "deployment.succeeded",
      "deployment.failed",
      "project.message.completed",
      "domain.verified",
      "balance.low"
    ]
  }'
```

Response:

```json
{
  "id": "whk_6Mn3",
  "url": "https://example.com/appmake",
  "events": [
    "deployment.succeeded",
    "deployment.failed",
    "project.message.completed",
    "domain.verified",
    "balance.low"
  ],
  "secret": "whsec_8dQ…"
}
```

## Events

`project.created`, `project.message.completed`, `project.message.awaiting_approval`, `deployment.succeeded`, `deployment.failed`, `domain.verified`, `domain.failed`, `balance.low`, `balance.empty`, `browser.task.requires_action`, `browser.task.completed`

## Check the signature

Each request has an `Appmake-Signature` header with a timestamp and an HMAC-SHA256 signature of `timestamp.body`, made with your secret. Reject requests older than five minutes.

```ts
import crypto from "node:crypto";

export function verify(body: string, header: string, secret: string) {
  const [t, v1] = header.split(",").map((p) => p.split("=")[1]);
  const expected = crypto.createHmac("sha256", secret).update(t + "." + body).digest("hex");
  const fresh = Date.now() / 1000 - Number(t) < 300;
  return fresh && crypto.timingSafeEqual(Buffer.from(v1), Buffer.from(expected));
}
```

Reply with a `2xx` within ten seconds. Failed deliveries are retried with backoff for up to 24 hours.

---

# Usage

Credits, balance and API tokens for a period, per project and per model.

Source: https://appmake.ai/docs/api/platform/usage

## Get usage

Use it for your own dashboards, or to bill clients for the usage of their workspace.

```bash
curl https://api.kalle.build/v1/usage?start=2026-11-01&end=2026-11-30 \
  -H "Authorization: Bearer $KALLE_API_KEY" \
  -H "Kalle-Version: 2026-11-01"
```

Response:

```json
{
  "period": {
    "start": "2026-11-01",
    "end": "2026-11-30"
  },
  "credits": {
    "included": 300,
    "used": 186
  },
  "balance": {
    "amount": 18.4,
    "currency": "EUR",
    "auto_refill": true
  },
  "by_project": [
    {
      "project_id": "prj_8Hq2c",
      "credits": 142
    }
  ],
  "api_tokens": {
    "input": 1840000,
    "output": 412000
  }
}
```

---

# Changelog

What's new in Appmake, Kalle by Appmake and the APIs.

Source: https://appmake.ai/docs/changelog

## 5 November 2026: Appmake Docs and the Platform API

Appmake Docs is live, with guides for every part of Appmake and a reference for both APIs. The [Platform API](https://appmake.ai/docs/api/platform/overview) lets you create projects, send project messages, publish, connect domains, query the database and receive webhooks.

## 1 November 2026: API version 2026-11-01

- Parallel tool calls in one reply
- New [count tokens](https://appmake.ai/docs/api/kalle/count-tokens) endpoint
- Max effort on Kalle Turbo Ultra

## 28 October 2026: Questions before the plan, and phases

Appmake now asks its questions in a panel next to the preview, with recommended answers picked. Bigger apps such as CRMs and Shopify storefronts are planned in phases. [Plan mode](https://appmake.ai/docs/guides/plan-mode).

## 20 October 2026: Appmake Cloud is live

Usage-based hosting for apps that need more, paid from the prepaid balance. [Appmake Cloud](https://appmake.ai/docs/platform/cloud).

## 12 October 2026: Kalle Browser for Firefox and Safari

Kalle Browser now works in Chrome, Edge, Brave, Arc, Firefox and Safari. [Kalle Browser](https://appmake.ai/docs/kalle/browser).

## 15 September 2026: Kalle by Appmake API

The first public version of the API, with Kalle Turbo, Kalle Design, Kalle Turbo Max and Kalle Turbo Ultra. [Get started](https://appmake.ai/docs/api/kalle/overview).