API Maker
The backend engine for the AI era
Full demo 14:30 39 chapters November 2026
The tour of the first API Maker demo, recorded again on API Maker v4. Install it with Launchpad, open the dashboard, connect a database and get the APIs of every table, read across six databases in one call, filter and save across engines, write a custom API and see where it spends its time, then the IDE and debugger, schedulers and WebSockets, websites rendered on the server, Index Maker, analytics, a Git pull on every server and engine upgrades.
In the playlists Start here
This is API Maker. You connect your databases, and you get a full backend: APIs, security, live updates, and much more.
It all starts in API Maker Launchpad. It is a desktop app. It runs API Maker on this computer, or on your own servers. Click New project. Type a name for its folder, and create it.
Now a short setup. First, choose how it runs: all in Docker, or as a normal program on this computer. Click Next. Give the project a name, and pick the version of API Maker. MongoDB and Redis will run next to it. Next, the ports. If a port is already in use, you see it at once. Last, you check everything before it runs.
All set. Click Install and start. API Maker downloads. MongoDB and Redis start. In a moment, API Maker is running. One click opens the admin panel.
After you sign in, you see this dashboard. Every page of API Maker opens from here. There are four groups: APIs and logic, security, databases, and operations. You can also type a word to find a page.
Now let us make APIs for a database. Open the Instance API page. It lists every database you connected. Click to add a new instance. Pick the database type. Here, it is SQL Server. The connection string comes from a secret, so you never type a password. Give it a name, test the connection, and save it.
The new instance is now in the list. Open it, and API Maker reads its databases right away. Open the warehouse database. You see its tables, and how many rows each one has. Even with no schema yet, every table already has its generic APIs.
Next, the schemas. A schema says what each column holds. Open Bulk Schema Creation. Select every table, and make all the schemas with one click.
Go back to the inventory table. Now it has the full set of APIs: get all, get by ID, save, update, delete, count, aggregate, and more. The schema APIs check every value with the schema. The generic APIs work without one. And we did not write one line of code.
You can try every API right here in the panel. Open API Testing, and choose what to call. First, the instance: MySQL. Then the database: sales. Then the table with the orders. And last, the API: get all.
Get all takes query parameters. Each one does what its name says. Limit the answer to five orders. Sort them by total, the biggest first. And select the fields you want back. Click Send. The five biggest orders come back.
Look at the shape of the answer. Every API answers in the same shape: success, a status code, and the data. Errors come back in this same shape too. So your app reads every answer the same way.
Each order keeps only the ID of its customer. The customers are in another database, PostgreSQL. Add deep on customer ID, and send again. Now every order brings its full customer, from the other database.
Deep can go as far as you need. Pick the API Query for get data. Open its body. Ask for one order, and five things linked to it. Send. Now the request and the full answer fit on one screen. The order comes from MySQL. Its customer comes from PostgreSQL. The coupon comes from MariaDB. The employee comes from Oracle. The products come from MongoDB. And the shipments come from SQL Server.
One request, one answer, six databases.
Filters can also work across databases. Open API Testing again. Pick the instance, MySQL. Then the database, sales. Then the orders table. This time, pick the API Query for get data.
Its body takes a filter. This filter asks for the orders of gold customers. But the gold level is saved with the customers, in PostgreSQL. Send. Only the orders of gold customers come back.
A filter can even go two tables away. Here, we ask for the orders of customers who live in Pune. Send. API Maker joins the tables for you, even when they are in different databases.
You can also save data across databases. Open API Testing, and choose what to call. The instance is PostgreSQL. The database is CRM. The table is customers. And the API is master save.
In the body, we write a new customer, her order, and two order lines. Orders and their lines are saved in MySQL. First, a mistake: one quantity is a word, not a number. The error comes back in the same shape. It names the field, and says what is wrong. Nothing is saved anywhere. Now we fix it. One call saves the customer in PostgreSQL, and her order and its lines in MySQL.
Now let us read it back. Pick Query for get data, and open its body. With deep, we ask for the customer, her orders, and their lines. Send. Everything is there, from both databases.
When you need your own logic, you write a custom API. Open Custom API, and add a new one. First, its settings: a name, a path, and a method. Then its code. It reads the orders from MySQL, with the same query parameters. Save it, and it is live.
From the list, you can test it right away. API Testing opens with it. Its code is on the left. Send, and its answer is on the right.
Every custom API also gets all of this, with no extra code: authorization, input validation, ready database and system APIs, automatic caching, translated errors, logs, utility classes, types for every table, and eight languages to write it in.
When your custom API works, you may ask: where does it spend its time? API Testing shows you, call by call. Here are two small custom APIs. They count the events of the orders, in a table of a million rows. Test the first one, and send it. When the answer is back, hide the request side, and open the Index Maker tab of the answer. Its timeline shows one bar for each database call.
The calls run one by one. Each count waits for the one before it. It looks like a staircase.
Open the second API from the menu. It runs the same three counts at the same time, with Promise dot all. Send it. Again, hide the request side, and open the Index Maker tab. Now the timeline shows three bars side by side. The run ends much sooner. So you see how your code loads its data, before your users feel it.
New in version four: a full code editor, an IDE, inside the panel. Open API Testing. Go to the custom APIs, and pick Order Quote. Open its code, and click the IDE button. Every file of your account is here, in one tree: custom APIs, events, schedulers, and websites, with their history.
When something goes wrong, you can debug it. Open API Testing again. Go to the custom APIs, and pick Cart Total. Open its code. Click in the margin to set a breakpoint. Click Send. The request stops on that line. You can open any variable, run code right where it stopped, go to the next line, watch a value, and continue to the answer. This works in every language API Maker runs.
Some work must run on a timer, not when an API is called. Open Schedulers, and add one. Give it a name, turn it on, and add an interval. We want it every minute, so pick Minute from the list. Then pick the time zone. We find India by its city. Save it. The panel shows the next run times right away.
Now its code. It reads the paid orders that still need packing, from MySQL. Then it writes how many there are to its log. Save it, and a server picks it up right away.
Open it again, and wait for the minute. It runs. The run is in the list, with how long it took. Its logs are one click away. Open the run. The console shows what the code wrote: the orders to pack.
Live updates are also built in. WebSocket events send data to your apps the moment it changes. Here, when an order is saved, and a custom event for its status. An event can have code. Open it, and look at its code. The code decides who can follow the event. Here, a customer follows only their own orders.
API Maker can also serve websites. You write the pages in TSX, next to your data, and the server builds each page. Here is the Calm Home shop, as a visitor sees it. Every page arrives complete, ready for search engines. One product page reads from four databases. And no API was written for any of it.
Is a query slow? Index Maker records the shape of every query your APIs run. Open the report of a time period. You see the calls to the database, with real samples of the slow one. The Suggestions tab shows the index it needs. Open it in the index form. Keep it out of the migration script for now, and create the index. A moment later, check again. Now the query uses the index.
Or let Index Maker do it by itself. In automatic mode, it records the real queries of your APIs from time to time. Its rules decide when a slow query gets an index, and what kind of index. Keep the default rules, and switch it on. Every index it makes goes into a migration script. So development, staging, and production all get the same indexes.
How is every server doing? Analytics shows you, from the real traffic of your APIs. Pick the last fifteen minutes, and pause the live refresh. You see the calls, the errors, the speed, and the cache hits. You also see how many rows of data were read from the six databases. Here is the traffic and the speed over time. Here are the busiest and the slowest APIs. And every API has its own numbers, custom APIs too.
You also see these numbers next to your code. On the Custom API page, every API shows its speed, its number of calls, and the size of its answers. The details are one click away. In the grid view, sort by speed, and the slowest APIs come first.
Your code can also live in Git. Open the Git page. This account follows the main branch, and a teammate just pushed a new shipping fee for Cart Quote. Click Pull. The panel shows each step on the server, live. It fetches the new code, checks it, and loads it. A few seconds later, it is done. There was no build, and no restart. Now we call Cart Quote on each server.
This setup runs two servers, and both use the new fee right away. One pull updates every server.
Updating API Maker itself is just as easy. The Upgrade Engine page shows the version that runs now. There are two ways to change it. You can upload a release, or pick a version from npm, newer or older. Every server installs it, and checks that it starts. If it does not start, it goes back by itself. And for your build pipeline, an engine webhook does the same thing, with one call.
Your pipeline calls it, and names the version it needs. The call answers at once. A second call asks how it is going. First, running, while every server installs it. Then restarting, until each server answers on the new version. And then done: every server runs it. Everything you saw starts from this dashboard. API Maker. Build faster, spend smarter, deliver better.
Length 4:21Panel tour
Length 9:33Launchpad
Length 8:37Install
Length 6:35Quick start