Start free

Build your backend in Cursor.

Cursor’s agent writes your backend in TypeScript with the Xano SDK, right in your editor, typed and checked as you go. Run it on the Xano Engine on your machine, then deploy it to Xano: database, APIs and hosting included.

Build with Cursor + Xano How coding agents build on Xano
$ npx @xano/sdk agent-skill install
Coding agent Cursor writes the TypeScript + Platform Xano runs it in production xano-backend agent skill init AGENTS.md Xano Engine your machine Xano cloud live URL local MCP server one set of rules · one path to production

Two-command setup

Install the xano-backend skill, then run init. It connects Cursor to the Xano Engine’s local MCP server, so your tables, rows, functions and tests are in reach from the first prompt.

TypeScript in your editor

Your backend is typed TypeScript in your project, so autocomplete and type checks cover every line the agent writes. Rename a column and every consumer lights up red.

Reviewed before it ships

Run it on the Xano Engine, test it, see what it compiled to in the builder, and promote to production only through a release.

Four stops on the SDK line

How to build backends in Cursor.

  1. 01 · Skill

    Install the skill.

    Add the xano-backend skill to each coding agent on your machine, Cursor included. When a project needs a backend and has none, the skill has Cursor’s agent confirm Xano with you, run init, deploy, and follow the AGENTS.md that init wrote.

    $ npx @xano/sdk agent-skill install
    Terminal $ npx @xano/sdk agent-skill install ✓ installed into each coding agent # or with the skills installer $ npx skills add xano-sdk/sdk SKILL.md xano-backend Cursor skill ready confirm Xano · run init · deploy · follow AGENTS.md
  2. 02 · Init

    Scaffold and connect.

    init writes a TypeScript backend under xano/, a React or Svelte frontend, the xano:deploy scripts and an AGENTS.md brief. It also connects Cursor to the Xano Engine’s local MCP server, where Cursor reads tables and rows, seeds data, and runs functions and tests. Already have an app? Run init inside it and it adds only the backend.

    $ npx @xano/sdk init my-app && cd my-app
    my-app/ xano/index.ts TypeScript backend frontend/ React or Svelte AGENTS.md brief for agents package.json xano:* scripts Xano Engine MCP server on your machine Cursor connected read tables seed data run tests
  3. 03 · Edit

    Chat, edit, and validate.

    Ask Cursor’s agent for tables, endpoints, or workflows. It writes TypeScript in your project files, grounded in llms.txt and AGENTS.md, and your editor checks every line. Tab-complete s., f. and input. to discover the whole catalog, and a backend rename is a compile error rather than a 404.

    xano/index.ts Cursor export const post = table({ name: "post", schema: { title: f.text({ required: true }), author: f.tableRef(user), }, }); stack: [ s. s.db.* s.math.* s.array.* s.text.* compile error column renamed: not a 404 later tab-complete s. f. input. grounded in llms.txt
  4. 04 · Ship

    Deploy and promote.

    npm run xano:deploy runs the backend on the Xano Engine on your machine and points your frontend at it. Open the builder link it prints to see what your code compiled to. Then npm run xano:deploy:ephemeral for a live URL on Xano’s cloud, and a release to reach your workspace.

    $ npm run xano:deploy
    $ npm run xano:deploy → Deploying ./xano/index.ts → Xano Engine ✓ Xano Engine xanosdk-4f2a91 deployed http://127.0.0.1:53358 Open the builder: http://127.0.0.1:53358/… Xano Engine your machine Ephemeral Xano’s cloud Workspace via a release the same code, from your laptop to production
Only in Cursor

Cursor project rules and the editor flow for a Xano backend

Cursor’s agent works inside your editor, so the backend is type-checked while it is written, not after. A short project rule keeps the agent on the AGENTS.md brief that init wrote.

One rule, pointing at AGENTS.md

Keep the brief in one place. A project rule in .cursor/rules/ scoped to xano/ tells Cursor’s agent to follow AGENTS.md and the SDK’s llms.txt, so the same brief serves Cursor and every other agent on the project.

Autocomplete is the API reference

Every kind, statement, filter and field type is typed. Tab-complete s., f., c., fl. and input. to find the whole catalog, and Cursor’s agent sees the same types you do.

Errors show up in the editor

A generated route manifest types your frontend’s calls, so renaming a backend column turns every consumer red: a compile error rather than a 404. Fix it in Cursor, then npm run xano:deploy.

Real data from the chat panel

init connects Cursor to the Xano Engine’s local MCP server, so the agent reads tables and rows, seeds data, and runs functions and tests without leaving the editor.

.cursor/rules/xano.mdc
---
description: Xano backend written with the Xano SDK
globs: xano/**
alwaysApply: false
---
Follow AGENTS.md (npx @xano/sdk init wrote it)
for every change under xano/.

- Write the backend in TypeScript with @xano/sdk.
- Look up the API in the SDK's llms.txt. Use
  autocomplete on s. f. c. fl. input. before guessing.
- Fix every type error before you deploy.
- After a change: npm run xano:deploy,
  then npx xanosdk test run-all.
Guide

Make AI-generated code safe for production

AI can generate apps fast. Xano can help you make them production-ready, reliable, and built to last.

How Xano governs AI-generated code
From your agent to production Cursor writes the code Types compiles Tests suite passes Release read back into production only when every check passes
Docs

Go deeper on the SDK

Every command on this page comes from the Xano SDK. See how coding agents build on Xano →

Guide

The authoring reference

Guide

Coverage & agent grounding

GitHub

The Xano SDK on GitHub

The platform under the line

Everything Cursor needs to build production backends.

Logic in Canvas View

See what your code compiled to as a Function Stack in Canvas View: transparent, auditable, human-readable.

Managed Postgres

Production-ready PostgreSQL with triggers, relationships, and direct access. No migrations, no DevOps.

API builder

Instant REST APIs with auth, rate limiting, and custom logic. Ready to connect to any frontend or service.

AI-assisted building

Describe your backend. AI builds schemas, APIs, auth, and logic, governed from the start.

Xano SDK + agent skill

Write the backend as typed TypeScript in your repo, from any IDE or agent, with full governance intact.

Observability & monitoring

Request tracing, performance dashboards, and audit logs across every system.

Environment management

Branch, test, and promote. Git-based versioning so nothing untested reaches production.

RBAC & compliance

HIPAA, SOC 2, GDPR, and ISO compliance with fine-grained access control. Built in from day one.
Questions

Cursor and the Xano SDK

How do I add Xano to Cursor?

Run npx @xano/sdk agent-skill install to add the xano-backend skill to Cursor (or npx skills add xano-sdk/sdk), then npx @xano/sdk init my-app. init connects Cursor to the Xano Engine’s MCP server; npx xanosdk local mcp shows how an agent connects.

Can I add Xano to an app I already have open in Cursor?

Yes. Run init inside the existing project and it adds only the backend: xano/, the xano:deploy scripts and AGENTS.md. If the backend already lives in a Xano workspace, init --from workspace reads it back as TypeScript, so Cursor’s agent edits your real endpoints instead of new ones.

Is there autocomplete for the SDK in Cursor?

Yes. Every kind, statement, filter and field type is typed, so your editor’s autocomplete is the fastest lookup: tab-complete s., f., c., fl. and input.. A generated route manifest types your frontend’s calls too, so a backend rename is a compile error rather than a 404.

What happens if Cursor generates something wrong?

The TypeScript compiler flags it in your editor, before you deploy. The tests you author run with npx xanosdk test run-all, and changes go to the Xano Engine or a disposable ephemeral first, so you test them and see what they compiled to before anything goes live.

Does Cursor need a rules file for Xano?

No, but a short one helps. init writes AGENTS.md, the brief every agent follows. A project rule in .cursor/rules/ scoped to xano/ can point Cursor’s agent at it, so Claude Code, Codex and Cursor all build to the same brief.

What if I want to change what Cursor wrote?

Edit it like any other file. The TypeScript lives in xano/ in your project, so you change it in Cursor, let the compiler check it, and redeploy. Canvas View in the Xano editor shows your team what it compiled to. Everything stays visible, editable and portable.

AI builds software. Xano makes it trustworthy.

Write it in Cursor. Run it on Xano.

Start free Talk to sales