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

# Tu backend

> Levanta las rutas de la billetera con el SDK de Node de Meru — un solo handler, tu api-key secreta se queda en el servidor.

El `backendBase` de los SDKs apunta a un servidor liviano que tú operas. Hace dos
cosas: guarda tu api-key **secreta** de Meru (nunca el frontend) y sirve las acciones
de la billetera que llama la app. El SDK de Node de Meru te da ambas en un solo handler.

## Instalar

```bash theme={null}
npm i @meru.app/node
```

Define tu api-key secreta como variable de entorno del servidor:

```bash theme={null}
MERU_API_KEY=sk_live_...
```

<Warning>
  `MERU_API_KEY` es un **secreto**. Mantenla en el servidor — nunca la envíes a la app
  ni la expongas en código de cliente. El frontend solo maneja el token de sesión de
  corta duración que devuelve el login.
</Warning>

## Montar el handler

`createMeruHandler` devuelve una función estándar Web `Request → Response`, así que
encaja en Next.js, Hono, Bun y Deno. Móntala en la ruta que usas como `backendBase`
(aquí `/api/meru`).

```ts app/api/meru/[...meru]/route.ts (Next.js) theme={null}
import { MeruClient, createMeruHandler } from "@meru.app/node";

const handler = createMeruHandler({
  client: new MeruClient({ apiKey: process.env.MERU_API_KEY! }),
  basePath: "/api/meru",

  // Autocustodia: nunca crear automáticamente una billetera gestionada. El usuario
  // abre su propia billetera en el dispositivo a propósito (eso hace `enroll()`).
  accountMode: "self-custody",

  // La app envía el token de sesión de Meru del usuario como Bearer. Identifica al
  // usuario a partir de él — las rutas de la billetera verifican el token de verdad.
  resolveUser: (req) => {
    const id = userIdFromMeruToken(req.headers.get("authorization"));
    return id ? { id } : null;
  },
});

export { handler as GET, handler as POST };
```

`userIdFromMeruToken` solo lee el id del usuario del token de sesión (un JWT cuyo
`sub` es `customer:<companyId>:<subjectId>` — la billetera se indexa por `subjectId`):

```ts theme={null}
function userIdFromMeruToken(authorization: string | null): string | null {
  const token = (authorization ?? "").replace(/^Bearer\s+/i, "");
  if (!token) return null;
  try {
    const payload = JSON.parse(
      Buffer.from(token.split(".")[1], "base64url").toString(),
    );
    const sub: string = payload.sub ?? "";
    return sub.split(":").slice(2).join(":") || null; // el subjectId
  } catch {
    return null;
  }
}
```

## Otros frameworks

Como el handler es `(Request) => Promise<Response>`:

<CodeGroup>
  ```ts Hono theme={null}
  app.all("/api/meru/*", (c) => handler(c.req.raw));
  ```

  ```ts Bun theme={null}
  Bun.serve({ port: 3200, fetch: handler });
  ```

  ```ts Deno theme={null}
  Deno.serve((req) => handler(req));
  ```
</CodeGroup>

Para Express (los `req`/`res` de Node), envuélvelo con un pequeño adaptador
Request/Response, o córrelo detrás de un runtime que hable el tipo Web `Request`.

## Qué sirve

Montado en `/api/meru`, el handler responde exactamente las rutas que llama el
cliente de billetera — no las implementas tú:

| Ruta                                                     | La usa              |
| -------------------------------------------------------- | ------------------- |
| `GET /accounts/me`                                       | `wallet.status()`   |
| `POST /accounts/self-custody`                            | `wallet.enroll()`   |
| `POST /accounts/self-custody/activate/build` · `/submit` | `wallet.activate()` |
| `POST /accounts/self-custody/recover`                    | `wallet.recover()`  |
| `POST /pay/crypto/build` · `/submit`                     | `wallet.send()`     |

<Note>
  Este es todo el backend para una billetera de autocustodia: un handler, una llave
  secreta. Los saldos e historial que la API pública no puede derivar por ti (si los
  quieres) se agregan como resolvers opcionales en `createMeruHandler` — ver la
  referencia del SDK de Node.
</Note>