Launch in days, not months
Connect your database and every table has secure APIs. Your team writes only what is unique to your product.
Auto generated APIsAPI Maker
The framework for AI era
The framework for AI era
8 databases, one API layer. Connect MongoDB, PostgreSQL, MySQL, SQL Server, Oracle, MariaDB, TiDB or Percona and get ~30 ready APIs for every table.
API Maker is a backend framework like
but API Maker is on steroids
Our Clients
Sava Info Systems
3 Way Technologies
D South
iBoon Technologies
Bytes Technolab
Hubwale
LNK Asia Techsol LLP
Odhav Technologies
Procure Genie
Virtue Info
Borough Taxi
Toupto Technologies
Folium
App Tale
Desire Info Web
Mart2GlobalEverything a backend needs on day one: APIs for your databases, your own TypeScript where it matters, and the security, speed and teamwork around them.
Connect a database and every table gets secure REST APIs: CRUD, queries, counts, distinct values, streams, deep populate and master save. No code to write.
GET /api/gen/admin/shop/main/productsRead more Write a TypeScript function, save it, and the API is live.
Read morePush live updates to web and mobile apps, only to the sockets that match.
Read moreIntervals or cron expressions, run once per cluster, with failover.
Read moreSwitch on caching per table or API. Writes through API Maker reset it.
Read moreBranches and pull requests, then a Git pull deploys in one transaction.
Read moreFind where a person can read rows that are not theirs, and fix many in one click.
Read moreFilter on fields of related tables, even in other databases, in one request.
Read moreHooks, events, multi-tenancy, secrets, SSO, logs, monitoring, tests and more.
Explore all featuresConnect a database and every table answers at a URL you can guess, with filters, sorting, paging, field selection, deep populate and streams. Call it from any language: it is plain REST.
Works with any frontend
curl -G https://api.example.com/api/gen/admin/shop/main/products \ --data-urlencode 'find={"stock":{"$gt":0}}' \ -d sort=-price -d limit=2 \ -H "x-am-authorization: $API_USER_TOKEN"const params = new URLSearchParams({ find: JSON.stringify({ stock: { $gt: 0 } }), sort: '-price', limit: '2',});const res = await fetch( `https://api.example.com/api/gen/admin/shop/main/products?${params}`, { headers: { 'x-am-authorization': token } },);const { data } = await res.json();import json, requestsres = requests.get( "https://api.example.com/api/gen/admin/shop/main/products", params={"find": json.dumps({"stock": {"$gt": 0}}), "sort": "-price", "limit": 2}, headers={"x-am-authorization": token},)products = res.json()["data"]final uri = Uri.https('api.example.com', '/api/gen/admin/shop/main/products', { 'find': jsonEncode({'stock': {'\$gt': 0}}), 'sort': '-price', 'limit': '2',});final res = await http.get(uri, headers: {'x-am-authorization': token});final products = jsonDecode(res.body)['data'];var url = URLComponents(string: "https://api.example.com/api/gen/admin/shop/main/products")!url.queryItems = [ URLQueryItem(name: "find", value: #"{"stock":{"$gt":0}}"#), URLQueryItem(name: "sort", value: "-price"), URLQueryItem(name: "limit", value: "2"),]var req = URLRequest(url: url.url!)req.setValue(token, forHTTPHeaderField: "x-am-authorization")let (data, _) = try await URLSession.shared.data(for: req){ "success": true, "statusCode": 200, "data": [ { "_id": "66fa1c…", "name": "Monitor", "price": 199, "stock": 5 }, { "_id": "66fa1d…", "name": "Keyboard", "price": 49, "stock": 12 } ]}What changes for your business: less to build, less to run, less that can go wrong.
Connect your database and every table has secure APIs. Your team writes only what is unique to your product.
Auto generated APIsValidation, caching, access checks, logs and deployment come built in: less code to write, review, test and maintain.
All featuresIt runs on 1 GB of RAM. On a 1 vCPU server it served 788 requests a second, with MongoDB and Redis on the same machine.
Low memory footprintGroups decide the APIs, tables and fields of every user. The security report finds data leaks and fixes many in one click.
APIs security reportBranches and pull requests, then a Git pull deploys in one transaction. A pull that fails changes nothing.
Git deploymentQuery, join and save across MongoDB, PostgreSQL, MySQL, SQL Server, Oracle, MariaDB, TiDB and Percona in one request.
Find and joinAn AI assistant writes code in seconds. On a traditional backend, all of that code is still yours to review, secure, test and scale. On API Maker, the assistant writes only the business logic, and the framework generates, checks and runs everything around it.
Point API Maker at your database: about 30 APIs for every table, on 8 database types, with TypeScript interfaces of your schemas.
Done by:API Maker
You decide what the product must do. Your AI assistant writes only the business logic: custom APIs, hooks and schedulers in TypeScript, in your own editor.
Done by:YouAI assistant
Every call passes the groups of its user, writes through the schema APIs are validated, and your hook code is read for data leaks.
Done by:API Maker
Test cases with mocks run on API Maker. Your assistant starts them with npm run test and reads the coverage.
Done by:AI assistantAPI Maker
Save and the API is live. A Git pull deploys it, and more servers with the same .env carry more traffic.
Done by:API Maker
Part of how API Maker runs, not something each project builds again.
The same rules for every API, whoever wrote the code: you, your team or your AI assistant.
The same project built three ways: by hand, with an AI assistant, and with an AI assistant on API Maker.
Traditional BackendCRUD and paging APIs written by hand for almost every table
+ AIAn assistant writes them in minutes, and each one is still code to review, test and maintain
Generated for every table the moment the database is connected: no endpoint code to maintain
Traditional BackendSeparate endpoints for the web app and the mobile app
+ AIQuick to add, so a new endpoint appears for every screen and the code base keeps growing
One API: each caller picks its filters, fields, sort, related rows and format
Traditional BackendJoins and saves across tables and databases written by hand
+ AIGenerated queries that still need checking for correct results and speed
Find and join, deep populate and master save across 8 database types
Traditional BackendEvery schema change means refactoring, retesting and new bugs
+ AIThe refactoring is faster, the retesting and the review are not
Generated APIs work on the table as it is, the schema is detected from it
Traditional BackendAccess checks copied into every endpoint
+ AIGenerated into every endpoint too, and one forgotten check is easy to miss in a review
Groups decide the APIs, tables and fields of every user, on every call
Traditional BackendA missing ownership check lets a person read rows that are not theirs
+ AIAn assistant adds the check when asked, but nothing shows where it is missing
The framework reads your groups, tokens and hook code, and shows a leak with the request that proves it
Traditional BackendEach fix designed, written and reviewed by hand
+ AIWritten fast, once someone knows exactly what to ask for
Many findings have a one-click action: a row scoping pre-hook, a token column, revoked grants
Traditional BackendSecurity reviewed now and then, when there is time
+ AIEvery change an assistant makes needs a new security review
While your local client is connected, changes are scanned on their own and the report goes to Git for your AI assistant
Traditional BackendEvery fix waits for a build and a deployment
+ AIThe fix is written in seconds, then waits for the same build and deployment
Save a custom API and it is live, no restart
Traditional BackendA deployment pipeline and servers to set up and keep running
+ AIAn assistant drafts the pipeline scripts, and you still run and fix them
A Git pull or a deployment hook deploys, in one transaction
Traditional BackendExtra tools and scripts to test the APIs
+ AITests are generated, and the runner, mocks and test data are still yours to wire
Test cases with mocks inside API Maker, run from the panel or with npm run test
Traditional BackendConfiguration differs between development and production
+ AIConfiguration files multiply with every environment, written by hand or not
The same code everywhere, only the secret of each environment changes
Traditional BackendCaching code written, and cleared, by hand
+ AICaching code comes quickly, and stale data bugs are still yours to find
Redis caching per table or API, reset by the writes
Traditional BackendMore servers means reworking sessions, caches and scheduled jobs
+ AIAn assistant can rework them, and the design and its risks stay with you
Add servers with the same .env: no sticky sessions, one shared cache, schedulers run once
Traditional BackendA memory leak or an endless loop takes the server down
+ AIGenerated code can hide the same leak or loop
Your code runs in sandboxes with time limits, renewed automatically
Traditional BackendLogs and monitoring stitched together from other tools
+ AIThe glue code is generated, and the tools still cost money and time to run
Logs of every call, metrics and health alerts are built in
Traditional BackendA new developer spends a long time setting up the backend
+ AIAn assistant explains the code, and the setup still takes as long
API Maker Local Run installs everything on macOS, Windows or Linux
Traditional BackendDevelopers step on each other on a shared database
+ AICode comes faster, and so do the collisions on the shared database
A developer account each: own database, own secrets, own Git branch
Traditional BackendEach part of the stack needs its own specialists
+ AIAn assistant fills gaps, and someone still has to own every part
TypeScript developers build the whole backend
Traditional BackendMoving an old project to new technology means a rewrite
+ AIThe rewrite goes faster, and it is still a rewrite to test
Point API Maker at the existing database: its APIs are ready
AI writes code faster. API Maker leaves far less code to write, and enforces security and scale from the framework itself.
Saves: TimeMoneyEffort · Use it and find more
A data leak is rarely a broken database or network. It is one missing check in one API. API Maker does not wait for an audit: the framework validates the code that you and your AI assistant write, prepares a report of where data could leak, and prepares the actions that fix it.
Groups, API users, auth providers, settings and the code of every pre-hook, parsed as TypeScript. Nothing runs, and nothing changes until you choose.
A score out of 100 and a grade from A to F. A leak of rows comes with the request that proves it.
A row scoping pre-hook, a column in the token, revoked grants, blocked inline SQL: many findings are fixed in one click, and you see the code first.
While your local client is connected, changes are scanned on their own and the report is committed to Git, where your AI assistant reads it.
D Data at risk
5 open0 fixed0 skipped
Each open finding takes points off 100: 20 critical, 10 high, 4 medium, 1 low.
"orders" is not scoped to the rows of the caller
GET …/shop/main/orders with the token of alice the orders of every customer
Group "Shop App" grants sensitive system APIs
A "find" can carry raw SQL on the SQL instances
Tokens of "app_users" live 90 days
"products" is not scoped to the rows of the caller
In your repository: src/API Security Report/ README.md · report.md · report.yaml · actions.yaml
What the report looks at
One install script. Any infrastructure. Your choice.
Ubuntu servers of EC2 sign in as ubuntu, and sudo -s opens the root shell the installer needs.
Load tests on Linode shared CPU servers, with MongoDB 6 and Redis on the same machine. You can deploy API Maker on any cloud provider.
788req/s
1,563 req/s with Redis cache
1,458req/s
2,971 req/s with Redis cache
2,759req/s
4,974 req/s with Redis cache
4,529req/s
6,475 req/s with Redis cache
Customer Reviews

API Maker made backend development easy with its auto-generated APIs and user-friendly interface. However, it takes some time to learn all the features.

API maker is very useful application for backend developer. It save man power efforts. It can do 80-100 hours work within 10-20 hours or less. Start using that and boost your efficiency and productivity.

I recently had the opportunity to explore API Maker, and I must say, I'm thoroughly impressed. Their product simplifies the process of generating APIs, offering a seamless experience from start to finish. The user interface is intuitive and user-friendly, making it easy to navigate even for those new to API development.

To create any type of software or web product fast and reliable I will always choose API Maker as backend. It has cutting edge tech with easily operating. The documentation and videos are very helpful to getting start.

I used in my two applications and it works very smooth. Custom APIs are so much powerful that I didn't expect. I recommend all freelancers and IT companies use this and enjoy the effortless work in backend.

Great Team with quality of product and services. API Maker is one of the game changers for all Developers.

Great Product and really helpful for generating custom APIs. Easy to use. Thank you for your great support.

Stop relying on traditional backend tools. API Maker is your ultimate all-in-one backend development solution. API Maker > 5x (Firebase + Supabase + Appwrite + GraphQL).

Great product… Very helpful to overcome repetitive tasks. Highly recommended!!!
Install API Maker, connect the database you already have, and build on top of it.
On your computer with API Maker Local Run, or on a server with one command.
Local Runcurl -fsSL https://apimaker.dev/v1/install.sh > install.sh && bash install.sh --version=latest --license_key=YOUR_KEY Put your license key in place of YOUR_KEY, and run it as root on a fresh Ubuntu 22.04, 24.04 or 26.04 server with 20 GB of disk. Get a license key
Add an instance for MongoDB, PostgreSQL, MySQL, SQL Server, Oracle, MariaDB, TiDB or Percona. Every table has its APIs at once.
Call the APIs from your apps, add custom APIs, hooks and schedulers in TypeScript, and deploy with a Git pull.