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

# Configuración del cliente

> Cómo crear y configurar el cliente de Base44.

<Warning>
  Esta página es parte de una habilidad de agente de codificación con IA y está escrita para agentes, no para humanos. Para la documentación de Base44 legible por humanos, consulta la [documentación para desarrolladores](/developers).
</Warning>

# Configuración del cliente

Cómo crear y configurar el cliente de Base44.

## Contenido

* [En apps generadas por Base44](#in-base44-generated-apps)
* [En apps externas](#in-external-apps)
* [En funciones de backend](#in-backend-functions)
* [Modos de autenticación](#authentication-modes) (Anónimo, Usuario, Rol de servicio)
* [Módulos disponibles](#available-modules)
* [Métodos del cliente](#client-methods)
* [Opciones de configuración del cliente](#client-configuration-options)

## En apps generadas por Base44

Dentro de una app de Base44, el cliente se crea y configura automáticamente. Impórtalo desde `@/api/base44Client` y úsalo como `base44`:

```javascript theme={null}
const tasks = await base44.entities.Task.list();
```

## En apps externas

Al usar Base44 como backend desde una app externa, instala el SDK y crea un cliente llamando a `createClient()` directamente:

```bash theme={null}
npm install @base44/sdk
```

```javascript theme={null}
import { createClient } from "@base44/sdk";

// IMPORTANTE: El nombre del parámetro es 'appId' (NO 'clientId', NO 'id')
// IMPORTANTE: onError debe estar anidado dentro del objeto 'options'
const base44 = createClient({
  appId: "your-app-id",          // Requerido: Usa el parámetro 'appId'
  token: "optional-user-token",  // Opcional: para solicitudes preautenticadas
  options: {                      // Opcional: opciones de configuración
    onError: (error) => {         // Opcional: manejador de errores (debe estar en options)
      console.error("Base44 error:", error);
    }
  }
});
```

**Errores comunes:**

* ❌ `createClient({ clientId: "..." })` - Nombre de parámetro INCORRECTO
* ❌ `createClient({ id: "..." })` - Nombre de parámetro INCORRECTO
* ❌ `createClient({ appId: "...", onError: ... })` - INCORRECTO: onError debe estar en options
* ✅ `createClient({ appId: "..." })` - Nombre de parámetro CORRECTO
* ✅ `createClient({ appId: "...", options: { onError: ... } })` - CORRECTO: onError en options

## En funciones de backend

`createClientFromRequest()` está diseñado para funciones de backend alojadas en Base44. Extrae la autenticación de las cabeceras de solicitud que Base44 inyecta y devuelve un cliente que incluye acceso de rol de servicio (`base44.asServiceRole`). Para frontends y backends externos, usa `createClient()` en su lugar.

```javascript theme={null}
import { createClientFromRequest } from "@base44/sdk";

Deno.serve(async (req) => {
  const base44 = createClientFromRequest(req);
  
  // El cliente hereda la autenticación de la solicitud
  const user = await base44.auth.me();
  
  return Response.json({ user });
});
```

## Modos de autenticación

| Modo                | Cómo obtenerlo                                                            | Permisos                         |
| ------------------- | ------------------------------------------------------------------------- | -------------------------------- |
| **Anónimo**         | `createClient({ appId })` sin token                                       | Solo datos públicos              |
| **Usuario**         | Después de `loginViaEmailPassword()` o mediante `createClientFromRequest` | Datos propios del usuario        |
| **Rol de servicio** | `base44.asServiceRole.*` en backend                                       | Acceso completo de administrador |

## Modo anónimo

Sin autenticación. Solo puede acceder a recursos públicos.

```javascript theme={null}
const base44 = createClient({ appId: "your-app-id" });

// Solo funciona si la entidad Task permite lectura anónima
const publicTasks = await base44.entities.Task.list();
```

## Modo usuario

Después de que el usuario inicia sesión, el cliente incluye automáticamente su token.

```javascript theme={null}
const base44 = createClient({ appId: "your-app-id" });

// El inicio de sesión establece el token
await base44.auth.loginViaEmailPassword("user@example.com", "password");

// Las solicitudes posteriores están autenticadas
const user = await base44.auth.me();
const myTasks = await base44.entities.Task.list();  // filtrado por permisos
```

## Modo rol de servicio

Acceso de nivel administrador. **Solo backend.**

```javascript theme={null}
// Dentro de una función de backend
Deno.serve(async (req) => {
  const base44 = createClientFromRequest(req);
  
  // Modo usuario - respeta permisos
  const myTasks = await base44.entities.Task.list();
  
  // Rol de servicio - evita permisos
  const allTasks = await base44.asServiceRole.entities.Task.list();
  const allUsers = await base44.asServiceRole.entities.User.list();
  const oauthToken = await base44.asServiceRole.connectors.getAccessToken("slack");
  
  return Response.json({ myTasks, allTasks });
});
```

## Módulos disponibles

El cliente expone estos módulos:

```javascript theme={null}
base44.agents        // Conversaciones de IA
base44.analytics     // Rastreo de eventos
base44.appLogs       // Registro de uso de app
base44.auth          // Autenticación
base44.connectors    // Flujos OAuth por usuario (UserConnectorsModule)
base44.entities      // Operaciones CRUD
base44.functions     // Invocación de funciones de backend
base44.integrations  // Servicios de terceros
base44.users         // Invitaciones de usuario

// Solo rol de servicio (backend)
base44.asServiceRole.agents
base44.asServiceRole.appLogs
base44.asServiceRole.connectors  // Tokens OAuth con ámbito de app (ConnectorsModule)
base44.asServiceRole.entities
base44.asServiceRole.functions
base44.asServiceRole.integrations
base44.asServiceRole.sso         // Generación de tokens SSO
```

## Métodos del cliente

El cliente proporciona estos métodos:

```javascript theme={null}
// Establecer el token de autenticación para todas las solicitudes posteriores
base44.setToken(newToken);

// Limpiar conexiones WebSocket (llama cuando termines con el cliente)
base44.cleanup();
```

### setToken

Actualiza el token de autenticación para todas las solicitudes API posteriores y conexiones WebSocket.

```javascript theme={null}
// Después de recibir un token (por ejemplo, de autenticación externa)
base44.setToken("new-jwt-token");
```

### cleanup

Desconecta las conexiones WebSocket. Llama cuando termines con el cliente o cuando el componente se desmonte.

```javascript theme={null}
// Limpieza al desmontar componente (ejemplo React)
useEffect(() => {
  return () => base44.cleanup();
}, []);
```

## Opciones de configuración del cliente

```javascript theme={null}
createClient({
  appId: "your-app-id",      // Requerido: DEBE usar 'appId' (no 'clientId' o 'id')
  token: "jwt-token",        // Opcional: token de autenticación preestablecido
  options: {                 // Opcional: opciones de configuración
    onError: (error) => {}   // Opcional: manejador de errores global (debe estar en options)
  }
});
```

**⚠️ Crítico:**

* El nombre del parámetro es `appId`, no `clientId` o `id`. Usar el nombre de parámetro incorrecto causará errores.
* El manejador `onError` debe estar anidado dentro del objeto `options`, no en el nivel superior.

## Definiciones de tipos

### CreateClientConfig

```typescript theme={null}
/** Configuración para crear un cliente de Base44. */
interface CreateClientConfig {
  /** El ID de app de Base44 (requerido). */
  appId: string;
  /** Token de autenticación de usuario. Se usa para autenticar como un usuario específico. */
  token?: string;
  /** @internal Token de rol de servicio; solo se establece automáticamente en funciones de backend alojadas en Base44. */
  serviceToken?: string;
  /** Opciones adicionales del cliente. */
  options?: CreateClientOptions;
}

/** Opciones para crear un cliente de Base44. */
interface CreateClientOptions {
  /** Manejador de errores opcional llamado cuando ocurre un error de API. */
  onError?: (error: Error) => void;
}
```

### Base44Client

```typescript theme={null}
/** La instancia del cliente de Base44. */
interface Base44Client {
  /** Módulo Agents para gestionar conversaciones de agente de IA. */
  agents: AgentsModule;
  /** Módulo Analytics para rastrear eventos personalizados. */
  analytics: AnalyticsModule;
  /** Módulo App logs para rastrear el uso de la app. */
  appLogs: AppLogsModule;
  /** Módulo Auth para autenticación y gestión de usuarios. */
  auth: AuthModule;
  /** Módulo Entities para operaciones CRUD en tus modelos de datos. */
  entities: EntitiesModule;
  /** Módulo Functions para invocar funciones de backend personalizadas. */
  functions: FunctionsModule;
  /** Módulo Integrations para llamar a métodos de integración prediseñados. */
  integrations: IntegrationsModule;

  /** Función de limpieza para desconectar conexiones WebSocket. */
  cleanup(): void;

  /** Establece un nuevo token de autenticación para todas las solicitudes posteriores. */
  setToken(newToken: string): void;

  /** Flujos OAuth por usuario. Cada usuario final tiene su propia conexión. */
  connectors: UserConnectorsModule;

  /** Proporciona acceso a módulos con permisos elevados de rol de servicio (solo backend). */
  readonly asServiceRole: {
    agents: AgentsModule;
    appLogs: AppLogsModule;
    /** Tokens OAuth con ámbito de app. Todos los usuarios comparten la misma cuenta conectada. */
    connectors: ConnectorsModule;
    entities: EntitiesModule;
    functions: FunctionsModule;
    integrations: IntegrationsModule;
    /** Generación de token SSO para usuarios. */
    sso: SsoModule;
    cleanup(): void;
  };
}
```

<Note>Esta página fue traducida usando IA. Para obtener la información más precisa y actualizada, consulta la [versión en inglés](/).</Note>