> ## Documentation Index
> Fetch the complete documentation index at: https://sdk.docs.xano.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Scaffold a TypeScript backend and a React frontend with npx @xano/sdk init, run the backend on the Xano Engine on your machine, and open the app, with no Xano account.

You go from an empty folder to a running app: a Xano backend on your machine and a frontend
that reads from it. No Xano account, no sign-in.

## Before you start

* Node.js 20.19 or later.
* macOS on Apple silicon, or Linux (x64 or arm64), for the Xano Engine.

<Note>
  **On Windows or an Intel Mac?** There is no Xano Engine build for your machine yet. Wherever this
  page says `npm run xano:deploy`, run `npm run xano:deploy:ephemeral` instead: it deploys the same
  code to an ephemeral in Xano's cloud. That needs a Xano account, so sign in first
  ([Connect to Xano](/start/connect-to-xano)). See
  [where the Engine differs today](/run/xano-engine#where-the-engine-differs-today).
</Note>

## Run it

<Steps>
  <Step title="Scaffold the project">
    ```bash theme={null}
    npx @xano/sdk init my-app
    cd my-app
    ```

    `init` writes a TypeScript backend under `xano/`, a React frontend under `frontend/`, and
    the `xano:*` scripts, then runs `npm install`. For Svelte pass `--framework svelte`; for a
    backend with no frontend, `--framework none`. In a terminal it asks which one, and Enter
    takes React.
  </Step>

  <Step title="Deploy the backend to the Xano Engine">
    <Tabs>
      <Tab title="macOS (Apple silicon) and Linux">
        ```bash theme={null}
        npm run xano:deploy
        ```

        This type-checks `xano/` and deploys it to the Xano Engine on your machine. The first
        run downloads the Engine for your platform and pins its version in `package.json`.
        Later runs start in seconds and work offline.

        ```
        → Deploying xano/index.ts → Xano Engine
        i Pinned Xano Engine v0.1.26 in my-app/package.json — commit it so everyone on this project runs the same engine.
          on Xano Engine · 127.0.0.1:53358 · workspace 1
        i Nothing to keep yet — this environment is new, so it is replaced and seeded. Later deploys with `--keep-data` keep its rows.
        ✓ Xano Engine xanosdk-4f2a91c03b7e deployed (4.4s)
        i New Xano Engine URL:
          http://127.0.0.1:53358
          Open the builder: http://127.0.0.1:53358/_engine/sign-in?key=…
          Meta API bearer (the local XANO_META_TOKEN): `npx xanosdk local token`
          MCP server for coding agents: http://127.0.0.1:53358/_engine/mcp — connect one with `npx xanosdk local mcp`
          Stop it with `npx xanosdk local stop xanosdk-4f2a91c03b7e`
          No static site was published. Run your frontend locally against the URL above, or pass `--static <dir>` to have the engine serve a built one.
          Pointed .env.local at this deploy (VITE_XANO_HOST) — restart your dev server to pick it up. `--no-dev-env` skips this.
        ```

        The output gives you three things: the backend URL, an **Open the builder** link, and
        a line saying it wrote that URL into `.env.local` as `VITE_XANO_HOST`.
      </Tab>

      <Tab title="Windows and Intel Mac">
        There is no Xano Engine build for these machines yet, so you deploy to an ephemeral in
        Xano's cloud instead. That needs a Xano account
        ([Connect to Xano](/start/connect-to-xano) walks through creating one).

        ```bash theme={null}
        npx xanosdk login
        npm run xano:deploy:ephemeral
        ```

        `login` opens your browser to sign in. `xano:deploy:ephemeral` builds the frontend and
        deploys it with the backend to an ephemeral. It prints the backend URL on
        `*.xano.io`, the frontend URL, and an `npx xanosdk impersonate` command that opens the
        builder. Open the frontend URL and skip the next step.
      </Tab>
    </Tabs>
  </Step>

  <Step title="Start the frontend">
    ```bash theme={null}
    npm run dev
    ```

    Vite reads `VITE_XANO_HOST` from `.env.local`, so the frontend calls the backend you just
    deployed. Open the URL Vite prints.
  </Step>

  <Step title="Open the builder">
    Open the **Open the builder** link from the deploy output. It signs you in to the Xano
    editor running on the Engine, where you can browse your tables and see what your
    TypeScript compiled to.
  </Step>
</Steps>

The starter backend is empty, so there is nothing to call yet. Your first table and endpoint
come next.

## Change something

Edit a file under `xano/`, then run `npm run xano:deploy` again. Each redeploy to the Engine
keeps the rows already in your tables (the script passes `--keep-data`). Keep `npm run dev`
running. `npm run xano:deploy -- --reset` gives you a clean, re-seeded backend.

## Next

* [What you built](/start/what-you-built): the files `init` wrote, which ones to commit, and
  which script deploys where.
* [Your first change](/build/first-change): add a table and an endpoint, and call it from the
  frontend.
* [Connect to Xano](/start/connect-to-xano): create a free account and deploy the same code to
  Xano's cloud.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.