+
+
+
+
+ 
+
+
+
+
+
+
+
+
+* **Solo valoración con pulgares**: Votación simple de pulgar arriba/abajo para medir la satisfacción general con las páginas.
+* **Solo comentarios sobre fragmentos de código**: Comentarios específicamente sobre fragmentos de código.
+* **Valoración con pulgares y comentarios contextuales**: Votación de página más comentarios detallados y motivos de las valoraciones.
+* **Valoración con pulgares y comentarios sobre fragmentos de código**: Votación de página más comentarios sobre ejemplos de código.
+* **Valoración con pulgares, comentarios contextuales y comentarios sobre fragmentos de código**: Sistema de comentarios completo con votación de página, comentarios detallados y comentarios sobre fragmentos de código.
+
+
+ ### Especificar la URL de tu API
+
+
+Para habilitar funciones de Mintlify como el Área de pruebas de API, agrega un campo `servers` a tu documento de OpenAPI con la URL base de tu API.
+
+```json
+{
+ "servers": [
+ {
+ "url": "https://api.example.com/v1"
+ }
+ ]
+}
+```
+
+En un documento de OpenAPI, los distintos endpoints de la API se especifican por sus rutas, como `/users/{id}` o simplemente `/`. La URL base define dónde deben añadirse estas rutas. Para más información sobre cómo configurar el campo `servers`, consulta [API Server and Base Path](https://swagger.io/docs/specification/api-host-and-base-path/) en la documentación de OpenAPI.
+
+El Área de pruebas de API usa estas URL de servidor para determinar adónde enviar las solicitudes. Si especificas varios servidores, un menú desplegable permitirá a los usuarios alternar entre ellos. Si no especificas un servidor, el Área de pruebas de API usará el modo simple, ya que no puede enviar solicitudes sin una URL base.
+
+Si tu API tiene endpoints que existen en diferentes URL, puedes [sobrescribir el campo de servidor](https://swagger.io/docs/specification/v3_0/api-host-and-base-path/#overriding-servers) para una ruta u operación específica.
+
+
+ ### Especificar la autenticación
+
+
+Para habilitar la autenticación en tu documentación y en el área de pruebas de la API, configura los campos `securitySchemes` y `security` en tu documento de OpenAPI. Las descripciones de la API y el Área de pruebas de API añadirán campos de autenticación según las configuraciones de seguridad de tu documento de OpenAPI.
+
+
+ ## Extensión `x-mint`
+
+
+La extensión `x-mint` es una extensión personalizada de OpenAPI que ofrece un mayor control sobre cómo se genera y se muestra la documentación de tu API.
+
+
+ ### Metadatos
+
+
+Sobrescribe los metadatos predeterminados de las páginas de API generadas agregando `x-mint: metadata` a cualquier operación. Puedes usar cualquier campo de metadatos válido en el frontmatter de `MDX`, excepto `openapi`:
+
+```json {7-13}
+{
+ "paths": {
+ "/users": {
+ "get": {
+ "summary": "Obtener usuarios",
+ "description": "Obtener una lista de usuarios",
+ "x-mint": {
+ "metadata": {
+ "title": "Listar todos los usuarios",
+ "description": "Obtener datos de usuarios paginados con opciones de filtrado",
+ "og:title": "Mostrar una lista de usuarios",
+ }
+ },
+ "parameters": [
+ {
+ // Configuración del parámetro
+ }
+ ]
+ }
+ }
+ }
+}
+```
+
+
+ ### Contenido
+
+
+Agrega contenido antes de la documentación de API generada automáticamente usando `x-mint: content`:
+
+```json {6-8}
+{
+ "paths": {
+ "/users": {
+ "post": {
+ "summary": "Crear usuario",
+ "x-mint": {
+ "content": "## Requisitos previos\n\nEste endpoint requiere privilegios de administrador y tiene límites de tasa.\n\n
+ ### Href
+
+
+Cambia la URL de la página del endpoint en tu documentación usando `x-mint: href`:
+
+```json {6-8, 14-16}
+{
+ "paths": {
+ "/legacy-endpoint": {
+ "get": {
+ "summary": "Endpoint heredado",
+ "x-mint": {
+ "href": "/deprecated-endpoints/legacy-endpoint"
+ }
+ }
+ },
+ "/documented-elsewhere": {
+ "post": {
+ "summary": "Endpoint especial"
+ "x-mint": {
+ "href": "/guides/special-endpoint-guide"
+ }
+ }
+ }
+ }
+}
+```
+
+Cuando `x-mint: href` está presente, la entrada de navegación enlaza directamente a la URL especificada en lugar de generar una página de API.
+
+
+ ### MCP
+
+
+Expón selectivamente endpoints como herramientas del Model Context Protocol (MCP) usando `x-mint: mcp`. Habilita solo los endpoints que sean seguros para el acceso público a través de herramientas de IA.
+
+
+ ## Rellenar automáticamente páginas de API
+
+
+Agrega un campo `openapi` a cualquier elemento de navegación en tu `docs.json` para generar automáticamente páginas para endpoints de OpenAPI. Puedes controlar dónde aparecen estas páginas en tu estructura de navegación, ya sea como secciones de API dedicadas o junto con otras páginas.
+
+El campo `openapi` acepta una ruta de archivo en tu repositorio de documentación o una URL a un documento de OpenAPI alojado.
+
+Las páginas de endpoints generadas tienen estos metadatos predeterminados:
+
+* `title`: El campo `summary` de la operación, si está presente. Si no hay `summary`, el título se genera a partir del método HTTP y del endpoint.
+* `description`: El campo `description` de la operación, si está presente.
+* `version`: El valor de `version` del ancla o pestaña principal, si está presente.
+* `deprecated`: El campo `deprecated` de la operación. Si es `true`, aparecerá una etiqueta de “deprecated” junto al título del endpoint en la navegación lateral y en la página del endpoint.
+
+
+ ### Secciones de API dedicadas
+
+
+Genera secciones de API dedicadas agregando un campo `openapi` a un elemento de navegación y sin otras páginas. Se incluirán todos los endpoints de la especificación:
+
+```json {5}
+"navigation": {
+ "tabs": [
+ {
+ "tab": "Referencia de la API"
+ "openapi": "https://petstore3.swagger.io/api/v3/openapi.json"
+ }
+ ]
+}
+```
+
+Puedes usar varias especificaciones de OpenAPI en diferentes secciones de navegación:
+
+```json {8-11, 15-18}
+"navigation": {
+ "tabs": [
+ {
+ "tab": "Referencia de la API",
+ "groups": [
+ {
+ "group": "Usuarios",
+ "openapi": {
+ "source": "/path/to/openapi-1.json",
+ "directory": "api-reference"
+ }
+ },
+ {
+ "group": "Administración"
+ "openapi": {
+ "source": "/path/to/openapi-2.json",
+ "directory": "api-reference"
+ }
+ }
+ ]
+ }
+ ]
+}
+```
+
+
+ ### Endpoints selectivos
+
+
+Cuando necesites más control sobre dónde aparecen los endpoints en tu documentación, puedes referenciar endpoints específicos en la navegación. Este enfoque te permite generar páginas para endpoints de API junto con otros contenidos.
+
+
+ #### Definir una especificación OpenAPI predeterminada
+
+
+Configura una especificación OpenAPI predeterminada para un elemento de navegación. Luego referencia endpoints específicos en el campo `pages`:
+
+```json {12, 15-16}
+"navigation": {
+ "tabs": [
+ {
+ "tab": "Primeros pasos",
+ "pages": [
+ "quickstart",
+ "installation"
+ ]
+ },
+ {
+ "tab": "Referencia de la API",
+ "openapi": "/path/to/openapi.json",
+ "pages": [
+ "api-overview",
+ "GET /users",
+ "POST /users",
+ "guides/authentication"
+ ]
+ }
+ ]
+}
+```
+
+Cualquier entrada de página que coincida con el formato `METHOD /path` generará una página de API para ese endpoint usando la especificación predeterminada de OpenAPI.
+
+
+ #### Herencia de la especificación de OpenAPI
+
+
+Las especificaciones de OpenAPI se heredan a lo largo de la jerarquía de navegación. Los elementos de navegación secundarios heredan la especificación de OpenAPI de su elemento principal, a menos que definan la suya propia:
+
+```json {3, 7-8, 11, 13-14}
+{
+ "group": "Referencia de la API",
+ "openapi": "/path/to/openapi-v1.json",
+ "pages": [
+ "overview",
+ "authentication",
+ "GET /users",
+ "POST /users",
+ {
+ "group": "Pedidos",
+ "openapi": "/path/to/openapi-v2.json",
+ "pages": [
+ "GET /orders",
+ "POST /orders"
+ ]
+ }
+ ]
+}
+```
+
+
+ #### Endpoints individuales
+
+
+Hace referencia a endpoints específicos sin establecer una especificación de OpenAPI predeterminada, incluyendo la ruta del archivo:
+
+```json {5-6}
+"navigation": {
+ "pages": [
+ "introducción",
+ "guías de usuario"
+ "/path/to/openapi-v1.json POST /users",
+ "/path/to/openapi-v2.json GET /orders"
+ ]
+}
+```
+
+Este enfoque es útil cuando necesitas endpoints individuales de distintas especificaciones o solo quieres incluir algunos endpoints seleccionados.
+
+
+ ## Crear archivos `MDX` para páginas de API
+
+
+Para controlar páginas de endpoints individuales, crea páginas `MDX` para cada operación. Esto te permite personalizar los metadatos de la página, añadir contenido, omitir ciertas operaciones o reordenar páginas en tu navegación a nivel de página.
+
+Consulta un [ejemplo de página de OpenAPI en MDX de MindsDB](https://github.com/mindsdb/mindsdb/blob/main/docs/rest/databases/create-databases.mdx?plain=1) y cómo aparece en su [documentación en producción](https://docs.mindsdb.com/rest/databases/create-databases).
+
+
+ ### Especificar archivos manualmente
+
+
+Crea una página `MDX` para cada endpoint y especifica qué operación de OpenAPI mostrar utilizando el campo `openapi` en el frontmatter.
+
+Cuando haces referencia a una operación de OpenAPI de esta manera, el nombre, la descripción, los parámetros, las respuestas y el Área de pruebas de API se generan automáticamente a partir de tu documento de OpenAPI.
+
+Si tienes varios archivos de OpenAPI, incluye la ruta del archivo en tu referencia para asegurarte de que Mintlify encuentre el documento de OpenAPI correcto. Si solo tienes un archivo de OpenAPI, Mintlify lo detectará automáticamente.
+
+
+ ### Generar archivos `MDX` automáticamente
+
+
+Utiliza nuestro [scraper](https://www.npmjs.com/package/@mintlify/scraping) de Mintlify para generar automáticamente páginas `MDX` para documentos de OpenAPI grandes.
+
+
+ ### Crear archivos `MDX` para esquemas de OpenAPI
+
+
+Puedes crear páginas individuales para cualquier esquema de OpenAPI definido en el campo `components.schema` de un documento de OpenAPI:
+
+
+ ## Webhooks
+
+
+Los webhooks son devoluciones de llamada HTTP que tu API envía para notificar a sistemas externos cuando se producen eventos. Los webhooks son compatibles en documentos de OpenAPI 3.1+.
+
+
+ ### Define webhooks en tu especificación de OpenAPI
+
+
+Agrega un campo `webhooks` a tu documento de OpenAPI junto al campo `paths`.
+
+Para obtener más información sobre cómo definir webhooks, consulta [Webhooks](https://spec.openapis.org/oas/v3.1.0#oasWebhooks) en la documentación de OpenAPI.
+
+
+ ### Referencia webhooks en archivos MDX
+
+
+Al crear páginas MDX para webhooks, usa `webhook` en lugar de métodos HTTP como `GET` o `POST`:
+
+```mdx
+---
+title: "Webhook de ejemplo"
+description: "Se activa cuando se produce un evento"
+openapi: "path/to/openapi-file webhook example-webhook-name"
+---
+```
+
+
+ ## Descripción general
+
+
+El Área de pruebas de API es un entorno interactivo que permite a los usuarios probar y explorar tus endpoints de API. Los desarrolladores pueden crear solicitudes de API, enviarlas y ver las respuestas sin salir de tu documentación.
+
+
+ 
+
+ 
+
+
+El Área de pruebas se genera automáticamente a partir de tu especificación OpenAPI o del esquema AsyncAPI, por lo que cualquier actualización de tu API se refleja automáticamente allí. También puedes crear manualmente páginas de referencia de API después de definir una URL base y un método de autenticación en tu `docs.json`.
+
+Recomendamos generar tu Área de pruebas de API a partir de una especificación OpenAPI. Consulta [Configuración de OpenAPI](/es/api-playground/openapi-setup) para obtener más información sobre cómo crear tu documento de OpenAPI.
+
+
+ ## Primeros pasos
+
+
+
+ ## Personalizar tu área de pruebas
+
+
+Puedes personalizar tu Área de pruebas de API definiendo las siguientes propiedades en tu `docs.json`.
+
+
+ ### Ejemplo de configuración
+
+
+```json
+{
+ "api": {
+ "playground": {
+ "display": "interactivo"
+ },
+ "examples": {
+ "languages": ["curl", "python", "javascript"],
+ "defaults": "obligatorio"
+ }
+ }
+}
+```
+
+Este ejemplo configura el área de pruebas de API para que sea interactiva e incluya fragmentos de código de ejemplo para cURL, Python y JavaScript. Solo se muestran los parámetros obligatorios en los fragmentos de código.
+
+
+ ### Páginas personalizadas de endpoints
+
+
+Cuando necesites más control sobre la documentación de tu API, usa la extensión `x-mint` en tu especificación de OpenAPI o crea páginas `MDX` individuales para tus endpoints.
+
+Ambas opciones te permiten:
+
+* Personalizar los metadatos de la página
+* Agregar contenido adicional, como ejemplos
+* Controlar el comportamiento del playground por página
+
+Se recomienda la extensión `x-mint` para que toda tu documentación de API se genere automáticamente a partir de tu especificación de OpenAPI y se mantenga en un solo archivo.
+
+Se recomiendan las páginas `MDX` individuales para APIs pequeñas o cuando quieras experimentar con cambios por página.
+
+Para obtener más información, consulta [Extensión x-mint](/es/api-playground/openapi-setup#x-mint-extension) y [Configuración de MDX](/es/api-playground/mdx/configuration).
+
+
+ ## Lecturas adicionales
+
+
+* [Configuración de AsyncAPI](/es/api-playground/asyncapi/setup) para obtener más información sobre cómo crear tu esquema de AsyncAPI y generar páginas de referencia de WebSocket.
\ No newline at end of file
diff --git a/es/api-playground/troubleshooting.mdx b/es/api-playground/troubleshooting.mdx
new file mode 100644
index 000000000..c9ee52a9b
--- /dev/null
+++ b/es/api-playground/troubleshooting.mdx
@@ -0,0 +1,106 @@
+---
+title: "Solución de problemas"
+description: "Problemas comunes con las referencias de API"
+icon: "message-square-warning"
+---
+
+Si tus páginas de API no se muestran correctamente, revisa estos problemas de configuración comunes:
+
+
+ ## Límites de uso
+
+
+La API del Asistente tiene los siguientes límites:
+
+- 10.000 usos por clave al mes
+- 10.000 solicitudes por organización de Mintlify por hora
+- 10.000 solicitudes por IP al día
+
+
+
+
+ ## Uso recomendado
+
+
+Para obtener los mejores resultados, utiliza el [hook useChat de ai-sdk](https://ai-sdk.dev/docs/reference/ai-sdk-ui/use-chat#usechat) para enviar solicitudes y gestionar respuestas.
+
+Puedes establecer `fp`, `threadId` y `filter` en el campo `body` del parámetro de opciones que se pasa al hook.
\ No newline at end of file
diff --git a/es/api-reference/assistant/create-topic.mdx b/es/api-reference/assistant/create-topic.mdx
new file mode 100644
index 000000000..dc00663e3
--- /dev/null
+++ b/es/api-reference/assistant/create-topic.mdx
@@ -0,0 +1,3 @@
+---
+openapi: POST /chat/topic
+---
diff --git a/es/api-reference/assistant/generate-message.mdx b/es/api-reference/assistant/generate-message.mdx
new file mode 100644
index 000000000..b1cdbbb37
--- /dev/null
+++ b/es/api-reference/assistant/generate-message.mdx
@@ -0,0 +1,3 @@
+---
+openapi: POST /chat/message
+---
diff --git a/es/api-reference/assistant/search.mdx b/es/api-reference/assistant/search.mdx
new file mode 100644
index 000000000..aad5f0e85
--- /dev/null
+++ b/es/api-reference/assistant/search.mdx
@@ -0,0 +1,3 @@
+---
+openapi: "POST /search/{domain}"
+---
diff --git a/es/api-reference/introduction.mdx b/es/api-reference/introduction.mdx
new file mode 100644
index 000000000..4c57a3604
--- /dev/null
+++ b/es/api-reference/introduction.mdx
@@ -0,0 +1,46 @@
+---
+title: "Introducción"
+description: "Activar actualizaciones, integrar el Asistente de IA y más"
+icon: "book-open"
+---
+
+La API REST de Mintlify te permite interactuar con tu documentación de forma programática, activar actualizaciones e integrar experiencias de chat con IA.
+
+
+ ## Endpoints
+
+
+* [Trigger update](/es/api-reference/update/trigger): Activa una actualización de tu sitio cuando lo necesites.
+* [Get update status](/es/api-reference/update/status): Obtén el estado de una actualización y otros detalles de tu documentación.
+* [Generate assistant message](/es/api-reference/assistant/create-assistant-message): Inserta el Asistente, entrenado con tu documentación, en cualquier aplicación que elijas.
+* [Search documentation](/es/api-reference/assistant/search): Busca en tu documentación.
+
+
+ ## Autenticación
+
+
+Puedes generar una clave de API desde el [panel de control](https://dashboard.mintlify.com/settings/organization/api-keys). Las claves de API están asociadas a toda la organización y se pueden usar en múltiples implementaciones.
+
+
+ ### Clave de API de administrador
+
+
+La clave de API de administrador se usa para los endpoints [Trigger update](/es/api-reference/update/trigger) y [Get update status](/es/api-reference/update/status).
+
+Las claves de API de administrador comienzan con el prefijo `mint_`. Mantén tus claves de API de administrador en secreto.
+
+
+ ### Clave de API del Asistente
+
+
+La clave de API del Asistente se usa para los endpoints [Generate assistant message](/es/api-reference/assistant/create-assistant-message) y [Search documentation](/es/api-reference/assistant/search).
+
+Las claves de API del Asistente comienzan con el prefijo `mint_dsc_`.
+
+La **clave** de la API del Asistente es un token del lado del servidor que debe mantenerse en secreto.
+
+El **token** de la API del Asistente es un token público que puede referenciarse en tu código de frontend.
+
+
+ ## Modos de autenticación
+
+
+Elige entre autenticación completa o parcial según tus necesidades de control de acceso.
+
+**Autenticación completa**: Todas las páginas están protegidas. Los usuarios deben iniciar sesión antes de acceder a cualquier contenido.
+
+**Autenticación parcial**: Algunas páginas son públicas, mientras que otras requieren autenticación. Los usuarios pueden explorar libremente el contenido público y autenticarse solo al acceder a páginas protegidas.
+
+Al configurar cualquiera de los métodos de autenticación a continuación, deberás seleccionar **Autenticación completa** o **Autenticación parcial** en la configuración del panel.
+
+
+ ## Configuración de la autenticación
+
+
+Selecciona el método de handshake que quieres configurar.
+
+
+ ## Hacer que las páginas sean públicas
+
+
+Al usar la autenticación parcial, todas las páginas están protegidas de forma predeterminada. Puedes hacer que páginas específicas sean visibles sin autenticación, a nivel de página o de grupo, con la propiedad `public`.
+
+
+ ### Nivel de página
+
+
+Para hacer pública una página, agrega `public: true` al frontmatter de la página.
+
+```mdx Ejemplo de página pública
+---
+title: "Página pública"
+public: true
+---
+```
+
+
+ ### Nivel de grupo
+
+
+Para que todas las páginas de un grupo sean públicas, agrega `"public": true` debajo del nombre del grupo en el objeto `navigation` de tu `docs.json`.
+
+```json Ejemplo de grupo público
+{
+ "navigation": {
+ "groups": [
+ {
+ "group": "Grupo público",
+ "public": true,
+ "icon": "play",
+ "pages": [
+ "quickstart",
+ "installation",
+ "settings"
+ ]
+ },
+ {
+ "group": "Grupo privado",
+ "icon": "pause",
+ "pages": [
+ "informacion-privada",
+ "ajustes-secretos"
+ ]
+ }
+ ]
+ }
+}
+```
diff --git a/es/authentication-personalization/overview.mdx b/es/authentication-personalization/overview.mdx
new file mode 100644
index 000000000..977cb5638
--- /dev/null
+++ b/es/authentication-personalization/overview.mdx
@@ -0,0 +1,74 @@
+---
+title: "Descripción general"
+description: "Controla quién ve tu documentación y personaliza su experiencia"
+icon: "badge-info"
+keywords: ["auth"]
+---
+
+
+ ### Ejemplos de uso
+
+
+**Elige autenticación completa cuando:**
+
+* Estés creando documentación interna de la empresa que contenga información sensible
+* Documentes APIs propietarias que requieran verificación de usuario
+* Crees guías de implementación específicas para clientes
+
+**Elige autenticación parcial cuando:**
+
+* Ofrezcas guías públicas de inicio con funciones avanzadas privadas
+* Administres un producto freemium donde los usuarios premium obtengan documentación adicional
+* Publiques documentación de código abierto con secciones empresariales privadas
+
+**Elige personalización cuando:**
+
+* Crees documentación pública de API que muestre ejemplos específicos del usuario
+* Construyas sitios de marketing que personalicen el contenido según los perfiles de usuario
+* Ofrezcas tutoriales públicos que se adapten a las preferencias o niveles de habilidad del usuario
+
+
+ ## Métodos de autenticación
+
+
+Elige el método que mejor se adapte a tu infraestructura y a tus requisitos de seguridad.
+
+| Método | Disponible para | Complejidad de configuración | Ideal para |
+|:-------|:----------------|:-----------------------------|:-----------|
+| **JWT** | Todos los enfoques | Media | Flujos de inicio de sesión personalizados, máximo control de seguridad |
+| **OAuth 2.0** | Todos los enfoques | Alta | Proveedores de autenticación de terceros, seguridad de nivel empresarial |
+| **Mintlify Dashboard** | Solo autenticación | Baja | Equipos que ya usan el panel de Mintlify |
+| **Password** | Solo autenticación | Baja | Acceso compartido simple sin personalización |
+| **Shared Session** | Solo personalización | Baja | Apps con autenticación basada en sesiones existente |
+
+
+ ### Cuándo usar cada método
+
+
+**JWT**: Úsalo cuando ya tengas un sistema de autenticación y quieras control total del flujo de inicio de sesión. Ideal para la gestión de usuarios personalizada o cuando necesites desacoplar el acceso a la documentación de tu aplicación principal.
+
+**OAuth 2.0**: Úsalo cuando quieras aprovechar proveedores de autenticación de terceros (Google, GitHub, etc.) o necesites estándares de seguridad de nivel empresarial. Ideal para organizaciones que ya usan infraestructura OAuth.
+
+**Mintlify Dashboard**: Úsalo cuando tus editores de documentación también sean los lectores. Perfecto para equipos internos que ya gestionan el contenido desde el panel de Mintlify.
+
+**Password**: Úsalo para un control de acceso sencillo cuando no necesites rastrear usuarios individuales ni personalizar contenido. Útil para contratistas, usuarios beta o accesos temporales.
+
+**Shared Session**: Úsalo cuando quieras un inicio de sesión transparente entre tu aplicación y la documentación. Ideal cuando los usuarios ya están autenticados en tu aplicación principal y quieres personalizar su experiencia en la documentación.
+
+
+ ## Personalización de contenido
+
+
+Los tres enfoques admiten funciones de personalización, como contenido MDX dinámico, prellenado de claves de API y controles de visibilidad de páginas. Para obtener pautas de implementación detalladas, consulta la [Configuración de personalización](/es/authentication-personalization/personalization-setup).
diff --git a/es/authentication-personalization/personalization-setup.mdx b/es/authentication-personalization/personalization-setup.mdx
new file mode 100644
index 000000000..a6dbe0ee1
--- /dev/null
+++ b/es/authentication-personalization/personalization-setup.mdx
@@ -0,0 +1,392 @@
+---
+title: "Configuración de Personalización"
+description: "Permite que los usuarios inicien sesión para obtener experiencias de documentación personalizadas"
+icon: "user-cog"
+---
+
+La Personalización adapta tu documentación a cada usuario cuando ha iniciado sesión. Por ejemplo, puedes completar previamente sus claves de API, mostrar contenido específico según su plan o rol, u ocultar secciones a las que no necesitan acceder.
+
+
+
+
+ ## Funciones de personalización
+
+
+Personaliza el contenido con estas capacidades de personalización.
+
+
+ ### Autorrelleno de clave de API
+
+
+Completa automáticamente los campos del Área de pruebas de API con valores específicos del usuario devolviendo nombres de campo que coincidan en tus datos de usuario. Los nombres de los campos en tus datos de usuario deben coincidir exactamente con los nombres del Área de pruebas de API para que el autorrelleno funcione.
+
+
+ ### Contenido MDX dinámico
+
+
+Muestra contenido dinámico según información del usuario como el nombre, el plan u organización usando la variable `user`.
+
+```jsx
+¡Bienvenido/a de nuevo, {user.firstName}! Tu plan {user.org?.plan} incluye...
+```
+
+Consulta la sección [Formato de datos de usuario](#user-data-format) más abajo para ver ejemplos detallados y orientación de implementación.
+
+
+ ### Visibilidad de la página
+
+
+Restringe qué páginas son visibles para tus usuarios añadiendo campos `groups` al frontmatter de tus páginas. De forma predeterminada, cada página es visible para todos los usuarios.
+
+Los usuarios solo verán las páginas de los `groups` a los que pertenezcan.
+
+```mdx
+---
+title: "Gestión de tus usuarios"
+description: "Añadir y eliminar usuarios de tu organización"
+groups: ["admin"]
+---
+```
+
+
+
+ ## Formato de datos del usuario
+
+
+Al implementar la personalización, tu sistema devuelve los datos del usuario en un formato específico que permite personalizar el contenido. Estos datos pueden enviarse como un objeto JSON sin procesar o dentro de un JWT firmado, según tu método de intercambio. La estructura de los datos es la misma en ambos casos.
+
+```tsx
+type User = {
+ expiresAt?: number;
+ groups?: string[];
+ content?: Record
+ ### Datos de usuario de ejemplo
+
+
+```json
+{
+ "expiresAt": 1735689600,
+ "groups": ["admin", "beta-users"],
+ "content": {
+ "firstName": "Jane",
+ "lastName": "Smith",
+ "company": "TechCorp",
+ "plan": "Enterprise",
+ "region": "us-west"
+ },
+ "apiPlaygroundInputs": {
+ "header": {
+ "Authorization": "Bearer abc123",
+ "X-Org-ID": "techcorp"
+ },
+ "server": {
+ "environment": "production",
+ "region": "us-west"
+ }
+ }
+}
+```
+
+
+
+ ## Configuración de la personalización
+
+
+Selecciona el método de handshake que deseas configurar.
+
+
+
+
+ ## Agregar ejemplos de código
+
+
+Puedes agregar fragmentos de código en línea o bloques de código. Los bloques de código admiten opciones meta para el resaltado de sintaxis, títulos, resaltado de líneas, iconos y más.
+
+
+ ### Código en línea
+
+
+Para indicar una `palabra` o `frase` como código, enciérrala entre acentos graves (`).
+
+```mdx
+Para marcar una `palabra` o `frase` como código, enciérrala entre comillas invertidas (`).
+```
+
+
+ ### Bloques de código
+
+
+Usa [bloques de código delimitados](https://www.markdownguide.org/extended-syntax/#fenced-code-blocks) encerrando el código entre tres comillas invertidas. Los bloques de código se pueden copiar y, si tienes el Asistente habilitado, los usuarios pueden pedirle a la IA que explique el código.
+
+Especifica el lenguaje de programación para el resaltado de sintaxis y para habilitar opciones meta. Agrega cualquier opción meta, como un título o un icono, después del lenguaje.
+
+```java HelloWorld.java lines icon="java"
+class HelloWorld {
+ public static void main(String[] args) {
+ System.out.println("¡Hola, Mundo!");
+ }
+}
+```
+
+````mdx
+```java HelloWorld.java lines icon="java"
+class HelloWorld {
+ public static void main(String[] args) {
+ System.out.println("¡Hola, Mundo!");
+ }
+}
+```
+````
+
+
+ ## Opciones de los bloques de código
+
+
+Puedes añadir opciones meta a tus bloques de código para personalizar su apariencia.
+
+
+ ### Sintaxis de opciones
+
+
+* **Opciones de cadena y booleanas**: Envuélvelas con `""`, `''` o sin comillas.
+* **Opciones de expresión**: Envuélvelas con `{}`, `""` o `''`.
+
+
+ ### Resaltado de sintaxis
+
+
+Activa el resaltado de sintaxis indicando el lenguaje de programación después de las comillas invertidas de apertura de un bloque de código.
+
+Usamos [Shiki](https://shiki.style/) para el resaltado de sintaxis y admitimos todos los lenguajes disponibles. Consulta la lista completa de [lenguajes](https://shiki.style/languages) en la documentación de Shiki.
+
+Personaliza globalmente los temas de los bloques de código usando `styling.codeblocks` en tu archivo `docs.json`. Establece temas simples como `system` o `dark`, o configura [temas de Shiki](https://shiki.style/themes) personalizados para los modos claro y oscuro. Consulta [Settings](/es/settings#styling) para ver las opciones de configuración detalladas.
+
+```java
+class HelloWorld {
+ public static void main(String[] args) {
+ System.out.println("¡Hola, Mundo!");
+ }
+}
+```
+
+````mdx
+```java
+class HelloWorld {
+ public static void main(String[] args) {
+ System.out.println("¡Hola, Mundo!");
+ }
+}
+```
+````
+
+
+ ### Título
+
+
+Añade un título para etiquetar tu ejemplo de código. Usa `title="Your title"` o una cadena en una sola línea.
+
+```javascript Code Block Example
+const hello = "mundo";
+```
+
+````mdx
+```javascript Ejemplo de Bloque de Código
+const hello = "world";
+```
+````
+
+
+ ### Icono
+
+
+Añade un icono a tu bloque de código con la propiedad `icon`. Consulta [Iconos](/es/components/icons) para ver todas las opciones disponibles.
+
+```javascript icon="square-js"
+const hello = "mundo";
+```
+
+````mdx
+```javascript icon="square-js"
+const hello = "world";
+```
+````
+
+
+ ### Resaltado de líneas
+
+
+Resalta líneas específicas en tus bloques de código usando `highlight` con los números de línea o los rangos que quieras resaltar.
+
+```javascript Line Highlighting Example highlight= {1-2,5}
+const greeting = "¡Hola, Mundo!";
+function sayHello() {
+ console.log(greeting);
+}
+sayHello();
+```
+
+````mdx
+```javascript Ejemplo de Resaltado de Líneas highlight={1-2,5}
+const greeting = "¡Hola, Mundo!";
+function sayHello() {
+ console.log(greeting);
+}
+sayHello();
+```
+````
+
+
+ ### Enfoque de líneas
+
+
+Resalta líneas específicas en tus bloques de código usando `focus` con números de línea o rangos.
+
+```javascript Line Focus Example focus= {2,4-5}
+const greeting = "¡Hola, Mundo!";
+function sayHello() {
+ console.log(greeting);
+}
+sayHello();
+```
+
+````mdx
+```javascript Line Focus Example focus={2,4-5}
+const greeting = "¡Hola, Mundo!";
+function sayHello() {
+ console.log(greeting);
+}
+sayHello();
+```
+````
+
+
+ ### Mostrar números de línea
+
+
+Muestra los números de línea en el lado izquierdo de tu bloque de código usando `lines`.
+
+```javascript Show Line Numbers Example lines
+const greeting = "¡Hola, Mundo!";
+function sayHello() {
+ console.log(greeting);
+}
+sayHello();
+```
+
+````mdx
+```javascript Mostrar números de línea Líneas de ejemplo
+const greeting = "¡Hola, Mundo!";
+function sayHello() {
+ console.log(greeting);
+}
+sayHello();
+```
+````
+
+
+ ### Expandible
+
+
+Permite que los usuarios expandan y contraigan bloques de código largos con `expandable`.
+
+```python Expandable Example expandable
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+
+@dataclass
+class Book:
+ title: str
+ author: str
+ isbn: str
+ checked_out: bool = False
+ due_date: Optional[datetime] = None
+
+class Library:
+ def __init__(self):
+ self.books: Dict[str, Book] = {}
+ self.checkouts: Dict[str, List[str]] = {} # usuario -> lista de ISBNs
+
+ def add_book(self, book: Book) -> None:
+ if book.isbn in self.books:
+ raise ValueError(f"El libro con ISBN {book.isbn} ya existe")
+ self.books[book.isbn] = book
+
+ def checkout_book(self, isbn: str, patron: str, days: int = 14) -> None:
+ if patron not in self.checkouts:
+ self.checkouts[patron] = []
+
+ book = self.books.get(isbn)
+ if not book:
+ raise ValueError("Libro no encontrado")
+
+ if book.checked_out:
+ raise ValueError("El libro ya está en préstamo")
+
+ if len(self.checkouts[patron]) >= 3:
+ raise ValueError("El usuario ha alcanzado el límite de préstamos")
+
+ book.checked_out = True
+ book.due_date = datetime.now() + timedelta(days=days)
+ self.checkouts[patron].append(isbn)
+
+ def return_book(self, isbn: str) -> float:
+ book = self.books.get(isbn)
+ if not book or not book.checked_out:
+ raise ValueError("Libro no encontrado o no está en préstamo")
+
+ late_fee = 0.0
+ if datetime.now() > book.due_date:
+ days_late = (datetime.now() - book.due_date).days
+ late_fee = days_late * 0.50
+
+ book.checked_out = False
+ book.due_date = None
+
+ # Remove from patron's checkouts
+ # Eliminar de los préstamos del usuario
+ if isbn in books:
+ books.remove(isbn)
+ break
+
+ return late_fee
+
+ def search(self, query: str) -> List[Book]:
+ query = query.lower()
+ return [
+ book for book in self.books.values()
+ if query in book.title.lower() or query in book.author.lower()
+ ]
+
+def main():
+ library = Library()
+
+ # Agregar algunos libros
+ books = [
+ Book("The Hobbit", "J.R.R. Tolkien", "978-0-261-10295-4"),
+ Book("1984", "George Orwell", "978-0-452-28423-4"),
+ ]
+
+ for book in books:
+ library.add_book(book)
+
+ # Ejemplo de préstamo y devolución
+ library.checkout_book("978-0-261-10295-4", "patron123")
+ late_fee = library.return_book("978-0-261-10295-4")
+ print(f"Multa por retraso: ${late_fee:.2f}")
+
+if __name__ == "__main__":
+ main()
+```
+
+````mdx
+```python Ejemplo Expandible expandible
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+
+# ...
+
+if __name__ == "__main__":
+ main()
+```
+````
+
+
+ ### Wrap
+
+
+Habilita el ajuste de texto para líneas largas con `wrap`. Esto evita el desplazamiento horizontal y facilita la lectura de líneas largas.
+
+```javascript Wrap Example wrap
+const greeting = "¡Hola, Mundo! Soy una línea larga de texto que se ajustará a la siguiente línea.";
+function sayHello() {
+ console.log(greeting);
+}
+sayHello();
+```
+
+````mdx
+```javascript Wrap Example wrap
+const greeting = "¡Hola, Mundo! Soy una línea larga de texto que se ajustará a la siguiente línea.";
+function sayHello() {
+ console.log(greeting);
+}
+sayHello();
+```
+````
+
+
+ ### Diff
+
+
+Muestra un diff visual de las líneas añadidas o eliminadas en tus bloques de código. Las líneas añadidas se resaltan en verde y las eliminadas se resaltan en rojo.
+
+Para crear diffs, agrega estos comentarios especiales al final de las líneas en tu bloque de código:
+
+* `// [!code ++]`: Marca una línea como añadida (resaltado en verde).
+* `// [!code --]`: Marca una línea como eliminada (resaltado en rojo).
+
+Para varias líneas consecutivas, especifica el número de líneas después de dos puntos:
+
+* `// [!code ++:3]`: Marca la línea actual más las dos siguientes como añadidas.
+* `// [!code --:5]`: Marca la línea actual más las cuatro siguientes como eliminadas.
+
+La sintaxis de los comentarios debe coincidir con tu lenguaje de programación (por ejemplo, `//` para JavaScript o `#` para Python).
+
+```js Diff Example icon="code" lines
+const greeting = "¡Hola, Mundo!"; // [!code ++]
+function sayHello() {
+ console.log("¡Hola, Mundo!"); // [!code --]
+ console.log(greeting); // [!code ++]
+}
+sayHello();
+```
+
+````text
+```js Ejemplo de Diff icon="code" lines
+const greeting = "¡Hola, Mundo!"; // [!code ++]
+function sayHello() {
+ console.log("¡Hola, Mundo!"); // [!code --]
+ console.log(greeting); // [!code ++]
+}
+sayHello();
+```
+````
diff --git a/es/components/accordions.mdx b/es/components/accordions.mdx
new file mode 100644
index 000000000..aac729359
--- /dev/null
+++ b/es/components/accordions.mdx
@@ -0,0 +1,112 @@
+---
+title: "Acordeones"
+description: "Componentes desplegables para mostrar y ocultar contenido"
+icon: "chevron-down"
+---
+
+import IconsOptional from "/snippets/es/icons-optional.mdx";
+
+Los acordeones permiten a los usuarios expandir y contraer secciones de contenido. Utiliza acordeones para la revelación progresiva y para organizar la información.
+
+
+
+ ## Acordeón individual
+
+
+
+ ## Grupos de acordeones
+
+
+Agrupa acordeones relacionados usando `
+ ## Propiedades
+
+
+
+ ## Propiedades
+
+
+
+ ## Tarjeta básica
+
+
+
+ ## Variantes de tarjetas
+
+
+Las tarjetas ofrecen varias opciones de diseño y estilo para adaptarse a distintas necesidades de contenido.
+
+
+ ### Diseño horizontal
+
+
+Agrega la propiedad `horizontal` para mostrar las tarjetas en un diseño horizontal más compacto.
+
+
+ ### Tarjetas con imagen
+
+
+Agrega la propiedad `img` para mostrar una imagen en la parte superior de la tarjeta.
+
+
+ ### Tarjetas de enlace con CTA personalizado
+
+
+Puedes personalizar el texto de la llamada a la acción y controlar si aparece una flecha. De forma predeterminada, las flechas solo se muestran en los enlaces externos.
+
+
+ ## Agrupar tarjetas
+
+
+Usa el [componente Columns](/es/components/columns) para organizar varias tarjetas lado a lado.
+
+
+ ## Propiedades
+
+
+
+ ## Creación de grupos de código
+
+
+Para crear un grupo de código, envuelve varios bloques de código con las etiquetas `
+ ## Menú desplegable de idiomas
+
+
+Puedes reemplazar las pestañas de un grupo de código por un menú desplegable para alternar entre idiomas usando la prop `dropdown`.
+
+
+ ## Propiedades
+
+
+
+ ## RequestExample
+
+
+Usa `
+ ## ResponseExample
+
+
+El componente `
+ ## Propiedades
+
+
+
+ ## Campo de parámetro
+
+
+El componente `
+ ### Propiedades
+
+
+
+ ## Campo de respuesta
+
+
+El componente `
+ ### Propiedades
+
+
+
+
+
+
+ ## Leyendas
+
+
+Puedes agregar contexto adicional a una imagen usando la prop opcional `caption`.
+
+
+ 
+
+
+
+ ## Propiedades
+
+
+
+
+```
+
+```mdx Frame with a caption
+
+
+
+```
+
+ ## Iconos en línea
+
+
+Los iconos se colocan en línea cuando se utilizan dentro de un párrafo.
+
+
+ ## Propiedades
+
+
+
+ ## Sintaxis
+
+
+Para crear un diagrama de Mermaid, escribe la definición del diagrama dentro de un bloque de código de Mermaid.
+
+````mdx
+```mermaid
+// Coloca aquí el código de tu diagrama de Mermaid
+```
+````
diff --git a/es/components/panel.mdx b/es/components/panel.mdx
new file mode 100644
index 000000000..467ba1b78
--- /dev/null
+++ b/es/components/panel.mdx
@@ -0,0 +1,21 @@
+---
+title: 'Panel'
+description: 'Especifica el contenido del panel lateral derecho'
+icon: 'panel-right'
+---
+
+Puedes usar el componente `
+ ## Props
+
+
+
+ ## Propiedades de Steps
+
+
+
+ ## Propiedades individuales de un paso
+
+
+
+ ## Propiedades
+
+
+
+ ## Propiedades
+
+
+
+
+
+ ### Novedades
+
+ * Diseño adaptable
+ * Ancla para cada actualización
+ * Entrada de RSS generada para cada actualización
+
+ ## Cómo usarlo
+
+
+```mdx Ejemplo de actualización
+
+ ## Props
+
+
+
+ ## Pregunta a nuestra documentación
+
+
+Selecciona Command + I para iniciar un chat con nuestro Asistente entrenado con nuestra documentación.
+
+
+ ## Mira tutoriales en video
+
+
+Visita nuestro canal de [YouTube](https://www.youtube.com/@GetMintlify/videos) para encontrar tutoriales y guías sobre el uso de Mintlify.
+
+
+ ## Soporte por mensajes
+
+
+Envíanos un mensaje desde tu [panel](https://dashboard.mintlify.com/) seleccionando **Support** en la barra lateral.
+
+
+
+
+ ## Soporte por correo electrónico
+
+
+Si no puedes acceder al panel, envíanos un correo a support@mintlify.com.
\ No newline at end of file
diff --git a/es/editor/branches.mdx b/es/editor/branches.mdx
new file mode 100644
index 000000000..c327fa05d
--- /dev/null
+++ b/es/editor/branches.mdx
@@ -0,0 +1,42 @@
+---
+title: "Trabajo con ramas"
+description: "Usa ramas para realizar y revisar cambios sin afectar tu documentación en producción"
+---
+
+Las ramas son una característica del control de versiones que apuntan a commits específicos en tu repositorio. Tu rama de despliegue, generalmente llamada `main`, representa el contenido con el que se construye tu documentación en producción. Todas las demás ramas son independientes de tu documentación en producción, a menos que decidas fusionarlas con tu rama de despliegue.
+
+Las ramas te permiten crear instancias separadas de tu documentación para hacer cambios, solicitar revisiones y probar nuevos enfoques antes de publicar. Tu equipo puede trabajar en ramas para actualizar distintas partes de la documentación al mismo tiempo sin afectar lo que los usuarios ven en tu sitio en producción hasta que publiques los cambios.
+
+Recomendamos trabajar siempre con ramas al actualizar la documentación para mantener estable tu sitio en producción y habilitar flujos de revisión.
+
+
+ ## Crear una rama
+
+
+1. Selecciona el nombre de la rama en la barra de herramientas del editor (generalmente `main` de forma predeterminada).
+2. Selecciona **New Branch**.
+3. Escribe un nombre descriptivo para la rama, como `update-getting-started` o `fix-api-examples`.
+4. Selecciona **Create Branch**.
+
+
+ ## Guardar cambios en una rama
+
+
+Para guardar tus cambios en una rama, selecciona el botón **Save Changes** en la esquina superior derecha del editor. Esto crea un commit y envía tu trabajo a tu rama.
+
+
+ ## Cambiar de rama
+
+
+1. Selecciona el nombre de la rama en la barra de herramientas del editor.
+2. Selecciona la rama a la que quieres cambiar en el menú desplegable.
+
+
+ ## Crear nuevas páginas
+
+
+
+ 
+
+ ### Ejemplo: agregar una página de temas
+
+
+```json title="Agregar una página de temas al grupo Profile" highlight="18"
+{
+ "navigation": {
+ "groups": [
+ {
+ "group": "Introducción",
+ "pages": [
+ "index",
+ "quickstart",
+ "installation"
+ ]
+ },
+ {
+ "group": "Perfil",
+ "pages": [
+ "settings",
+ "account-types",
+ "dashboard",
+ "themes"
+ ]
+ }
+ ]
+ }
+}
+```
+
+
+
+ ## Edición de contenido
+
+
+Realiza cambios en tus páginas usando el modo visual o el modo Markdown en el editor.
+
+En el modo visual, presiona / para abrir el menú de componentes. Agrega bloques de contenido, avisos, bloques de código y otros componentes para personalizar tu documentación.
+
+
+ 
+ 
+
+
+En el modo Markdown, puedes editar directamente el `MDX` de tus páginas. Esto puede ser útil cuando necesitas:
+
+- Definir propiedades específicas de los componentes
+- Trabajar con componentes anidados complejos
+- Copiar y pegar contenido `MDX` de otras fuentes
\ No newline at end of file
diff --git a/es/editor/getting-started.mdx b/es/editor/getting-started.mdx
new file mode 100644
index 000000000..b041ab7a4
--- /dev/null
+++ b/es/editor/getting-started.mdx
@@ -0,0 +1,92 @@
+---
+title: "Primeros pasos con el editor web"
+sidebarTitle: "Primeros pasos"
+description: "Aprende a crear y editar documentación con el editor web"
+---
+
+
+
+
+
+El editor web es una interfaz visual para crear, editar y revisar documentación directamente en tu navegador.
+
+* **Edición visual**: Realiza cambios en tu documentación con un editor WYSIWYG (lo que ves es lo que obtienes) que muestra cómo se verá tu contenido al publicarse.
+* **Sincronización con Git**: Todos los cambios se sincronizan automáticamente con tu repositorio de Git para mantener el control de versiones.
+* **Colaboración en equipo**: Varias personas pueden trabajar en la documentación simultáneamente.
+* **Integración de componentes**: Agrega avisos, bloques de código y otros componentes con comandos de barra inclinada.
+* **Sin configuración**: Comienza a escribir de inmediato desde tu panel.
+
+
+ ## Flujo de trabajo del Editor web
+
+
+Así es como normalmente trabajarás en el Editor web:
+
+
+ ## Modos del editor
+
+
+El editor web tiene dos modos para adaptarse a distintas preferencias y necesidades de edición. Usa el conmutador en la esquina superior derecha de la barra de herramientas del editor para cambiar entre los modos de edición.
+
+
+ 
+
+ 
+
+
+
+ ### Modo visual
+
+
+El modo visual ofrece una experiencia WYSIWYG en la que los cambios que hagas en el editor son los que se publicarán en tu sitio de documentación. Este modo es ideal cuando quieres ver en tiempo real cómo se verán tus cambios.
+
+Pulsa `/` para abrir el menú de componentes y añadir contenido con estilo, avisos, fragmentos de código u otros componentes.
+
+
+ 
+
+ 
+
+
+
+ ### Modo Markdown
+
+
+El modo Markdown ofrece acceso directo al código `MDX` subyacente de tu documentación. Este modo es ideal cuando necesitas un control preciso sobre las propiedades de los componentes o cuando prefieres escribir con la sintaxis de Markdown.
+
+
+ 
+
+ 
+
+
+
+ ## Próximos pasos
+
+
+* Aprende los conceptos fundamentales de [Git](/es/editor/git-concepts).
+* Conoce las prácticas recomendadas para colaborar con [ramas](/es/editor/branches).
+* Explora la [gestión de contenido](/es/editor/content-management) con el Editor web.
+* Comprende las [opciones de publicación](/es/editor/publishing) para distintos escenarios.
\ No newline at end of file
diff --git a/es/editor/git-concepts.mdx b/es/editor/git-concepts.mdx
new file mode 100644
index 000000000..bb46ee9dd
--- /dev/null
+++ b/es/editor/git-concepts.mdx
@@ -0,0 +1,66 @@
+---
+title: "Conceptos de Git"
+description: "Aprende los fundamentos de Git para el flujo de trabajo de documentación como código"
+---
+
+Git es un sistema de control de versiones que te permite realizar un seguimiento de los cambios en tu documentación y colaborar con tu equipo. Con Git, para cada archivo de tu proyecto puedes ver qué cambió, cuándo y por qué. Git también facilita volver a versiones anteriores de los archivos cuando lo necesites.
+
+El editor web realiza algunas operaciones de Git en segundo plano. Entender estos conceptos te ayudará a trabajar de forma más eficaz con el editor web y a colaborar con miembros del equipo que trabajan en sus entornos de desarrollo locales.
+
+
+ ## Conceptos básicos de Git
+
+
+
+ ## Cómo utiliza Git el editor web
+
+
+El editor web se conecta a tu repositorio de Git a través de la [GitHub App](/es/settings/github) o la [integración con GitLab](/es/settings/gitlab) y automatiza operaciones comunes de Git.
+
+Cuando:
+
+* **Abres un archivo**: El editor obtiene la versión más reciente de tu repositorio, garantizando que siempre trabajes con contenido actualizado.
+* **Realizas cambios**: El editor registra tus cambios como un borrador que puede convertirse en un commit cuando estés listo para guardar tu trabajo.
+* **Guardas cambios**: El editor crea un commit con tus cambios, preservando tu trabajo en el historial del proyecto.
+* **Creas una rama**: El editor crea una nueva rama en tu repositorio que puede ser utilizada por cualquier persona con acceso al repositorio para colaborar y revisar los cambios.
+* **Publicas en tu rama de despliegue**: El editor hace commit y push directamente a tu rama de despliegue, lo que publica tus cambios de inmediato.
+* **Publicas en otras ramas**: El editor crea una pull request, lo que te permite recibir comentarios de otros antes de fusionar tus cambios en tu rama de despliegue.
+
+
+ ## Mejores prácticas de Git
+
+
+Cada equipo desarrollará sus propios flujos de trabajo y preferencias, pero estas son algunas prácticas generales para empezar.
+
+* **Escribe mensajes de commit descriptivos**: Sé específico sobre qué cambió y utiliza un lenguaje activo.
+* **Usa nombres de rama descriptivos**: Los nombres de las ramas deben explicar el trabajo que se está realizando y ser significativos para quien las consulte en tu repositorio.
+* **Mantén las ramas enfocadas**: Limita los cambios en una rama a una tarea o proyecto específico.
+* **Elimina las ramas después de hacer merge**: Borra las ramas cuando ya no las necesites para mantener tu repositorio ordenado.
\ No newline at end of file
diff --git a/es/editor/keyboard-shortcuts.mdx b/es/editor/keyboard-shortcuts.mdx
new file mode 100644
index 000000000..df5ee8981
--- /dev/null
+++ b/es/editor/keyboard-shortcuts.mdx
@@ -0,0 +1,27 @@
+---
+title: "Atajos de teclado"
+description: "Atajos del editor web"
+---
+
+El editor web admite todos los atajos de teclado habituales, como copiar, pegar, deshacer y seleccionar todo, además de los siguientes:
+
+| Comando | macOS | Windows |
+|:--------|:------|:--------|
+| **Buscar archivos** | Cmd + P | Control + P |
+| **Añadir enlace al texto seleccionado** | Cmd + K | Control + K |
+| **Insertar salto de línea** | Cmd + Enter | Control + Enter |
+| **Negrita** | Cmd + B | Control + B |
+| **Cursiva** | Cmd + I | Control + I |
+| **Subrayado** | Cmd + U | Control + U |
+| **Tachado** | Cmd + Shift + S | Control + Shift + S |
+| **Código** | Cmd + E | Control + E |
+| **Texto normal** | Cmd + Alt + 0 | Control + Alt + 0 |
+| **Encabezado 1** | Cmd + Alt + 1 | Control + Alt + 1 |
+| **Encabezado 2** | Cmd + Alt + 2 | Control + Alt + 2 |
+| **Encabezado 3** | Cmd + Alt + 3 | Control + Alt + 3 |
+| **Encabezado 4** | Cmd + Alt + 4 | Control + Alt + 4 |
+| **Lista numerada** | Cmd + Shift + 7 | Control + Shift + 7 |
+| **Lista con viñetas** | Cmd + Shift + 8 | Control + Shift + 8 |
+| **Cita en bloque** | Cmd + Shift + B | Control + Shift + B |
+| **Subíndice** | Cmd + , | Control + , |
+| **Superíndice** | Cmd + . | Control + . |
\ No newline at end of file
diff --git a/es/editor/publishing.mdx b/es/editor/publishing.mdx
new file mode 100644
index 000000000..20772945a
--- /dev/null
+++ b/es/editor/publishing.mdx
@@ -0,0 +1,79 @@
+---
+title: "Publicación de tus cambios"
+description: "Despliega las actualizaciones de tu documentación directamente a producción o mediante pull requests"
+---
+
+Cómo se publiquen tus cambios depende de la rama en la que estés trabajando:
+
+* **Rama de despliegue**: Publicar actualiza tu sitio en producción de inmediato.
+* **Otras ramas**: Publicar crea un pull request para que puedas revisar los cambios antes de desplegarlos en producción.
+
+
+ 
+ 
+
+
+
+ ## Pull requests y revisión de cambios
+
+
+Los pull requests te permiten proponer cambios desde tu rama para que otras personas los revisen antes de integrarlos en tu documentación en producción. Esto ayuda a garantizar que tus cambios sean correctos y le da a tu equipo la oportunidad de colaborar en el contenido.
+
+
+ ### Crear una pull request
+
+
+
+ 
+
+
+ ## Revisar pull requests
+
+
+Una vez creado el pull request:
+
+1. **Revisar cambios**: Tú y tu equipo pueden revisar el pull request en tu proveedor de Git, como GitHub o GitLab.
+2. **Dejar comentarios**: Agrega comentarios o solicita cambios.
+3. **Hacer cambios adicionales**: Realiza cambios adicionales en el Editor web. Al guardar, el editor los envía a tu pull request.
+4. **Aprobar**: Aprueba el pull request cuando estés satisfecho con los cambios.
+5. **Fusionar**: Fusiona el pull request cuando estés listo para desplegar tus cambios a producción.
\ No newline at end of file
diff --git a/es/editor/troubleshooting.mdx b/es/editor/troubleshooting.mdx
new file mode 100644
index 000000000..e692f1323
--- /dev/null
+++ b/es/editor/troubleshooting.mdx
@@ -0,0 +1,62 @@
+---
+title: "Solución de problemas del editor web"
+sidebarTitle: "Solución de problemas"
+description: "Soluciones a problemas comunes"
+---
+
+Encuentra soluciones a problemas comunes que puedes encontrar al usar el editor web.
+
+
+ ## Acerca del asistente
+
+
+El Asistente responde preguntas sobre tu documentación mediante consultas en lenguaje natural. Está integrado directamente en tu sitio de documentación, brindando a los usuarios acceso inmediato a ayuda contextual.
+
+El Asistente utiliza RAG agentivo (generación aumentada por recuperación) con llamadas a herramientas, impulsado por Claude Sonnet 4. Cuando los usuarios hacen preguntas, el Asistente:
+
+* **Busca y recupera** contenido relevante de tu documentación para ofrecer respuestas precisas.
+* **Cita las fuentes** y proporciona enlaces navegables que llevan a los usuarios directamente a las páginas de referencia.
+* **Genera ejemplos de código para copiar** que ayudan a los usuarios a implementar soluciones a partir de tu documentación.
+
+Cada mensaje enviado al Asistente cuenta para el cupo de mensajes de tu plan. Si superas tu cupo, los mensajes adicionales generarán cargos por excedente. Puedes establecer límites de gasto o desactivar el Asistente si alcanzas tu cupo de mensajes.
+
+Puedes ver el uso del Asistente en tu panel para comprender el comportamiento de los usuarios y la efectividad de la documentación. Exporta y analiza los datos de las consultas para ayudar a identificar:
+
+* Preguntas frecuentes que podrían necesitar mejor cobertura.
+* Vacíos de contenido donde los usuarios tienen dificultades para encontrar respuestas.
+* Temas populares que podrían beneficiarse de contenido adicional.
+
+
+ ## Configuración del asistente
+
+
+El Asistente está habilitado de forma predeterminada para los planes Pro y Custom. Puedes administrarlo desde tu [panel](https://dashboard.mintlify.com/products/assistant/settings), donde puedes activarlo o desactivarlo, configurar el manejo de respuestas y establecer un límite de gasto.
+
+
+ ### Estado del Asistente
+
+
+Alterna el estado del Asistente para habilitarlo o deshabilitarlo en tu sitio de documentación.
+
+
+ ### Desvío del Asistente
+
+
+Permite que el Asistente redirija las preguntas sin respuesta a tu equipo de soporte. Proporciona una dirección de correo electrónico que el Asistente compartirá con los usuarios que hagan preguntas a las que no pueda responder.
+
+
+ ### Búsqueda en sitios
+
+
+
+ ### Límite de gasto
+
+
+Establece un límite de gasto para controlar qué sucede si alcanzas tu cupo de mensajes. De forma predeterminada, el Asistente seguirá respondiendo preguntas de los usuarios después de que alcances tu cupo, lo que genera cargos por excedente.
+
+En la pestaña **Billing** de la página [Assistant Configurations](https://dashboard.mintlify.com/products/assistant/settings), puedes establecer un límite de gasto para los mensajes del Asistente que superen tu cupo. Cuando alcanzas tu límite de gasto, el Asistente se deshabilita hasta que tu cupo de mensajes se restablezca.
+
+También puedes configurar alertas de uso para recibir un correo electrónico cuando alcances un porcentaje determinado de tu límite de gasto.
+
+
+ ## Uso del Asistente
+
+
+Los usuarios pueden acceder al Asistente de tres maneras:
+
+* **Atajos de teclado**: ? o Command + I (Ctrl + I en Windows)
+* **Botón del Asistente** junto a la barra de búsqueda
+ 
+ 
+* **URLs** con `?assistant=open` al final abrirán el Asistente cuando cargue la página. Por ejemplo, [https://mintlify.com/docs?assistant=open](https://mintlify.com/docs?assistant=open).
+
+Todos los métodos abren un panel de chat en el lado derecho de tu documentación. Los usuarios pueden hacer cualquier pregunta y el Asistente buscará en tu documentación una respuesta. Si no se encuentra información relevante, el Asistente responderá que no puede responder la pregunta.
+
+
+ ## Hacer que el contenido sea apto para la ingesta por IA
+
+
+Estructura tu documentación para ayudar al Asistente a ofrecer respuestas precisas y relevantes. Una organización clara y un contexto completo benefician tanto a las personas lectoras como a la comprensión de la IA.
+
+
+ ## Exportar y analizar consultas
+
+
+Revisa y exporta consultas desde tu panel para entender cómo las personas interactúan con tu documentación e identificar oportunidades de mejora. Algunas maneras en que el análisis de consultas puede ayudarte a mejorar tu documentación:
+
+* Identifica brechas de contenido donde las consultas frecuentes reciben respuestas insuficientes.
+* Descubre patrones de comportamiento de los usuarios y necesidades de información comunes a partir de los temas y patrones en las consultas.
+* Prioriza las páginas con mayor tráfico para mejorar su precisión y calidad.
+
+Puedes explorar consultas desde tu [panel](https://dashboard.mintlify.com/products/assistant), pero para obtener información más sólida te recomendamos exportar un archivo `CSV` con tus consultas, respuestas y fuentes para analizarlo con tu herramienta de IA preferida.
+
+1. Ve a la [página del Asistente](https://dashboard.mintlify.com/products/assistant) en tu panel.
+2. Selecciona **Export to CSV**.
+3. Analiza los datos exportados con tu herramienta preferida.
+
+
+ ## Descripción general
+
+
+Esta guía te acompaña paso a paso para configurar Auth0 como proveedor de autenticación para tu documentación de Mintlify. Al finalizar, tus usuarios podrán iniciar sesión en tu documentación con sus credenciales de Auth0.
+
+
+ ## Configurar tu registro de cambios
+
+
+
+ ## Personalizar el registro de cambios
+
+
+Controla cómo las personas navegan por tu registro de cambios y se mantienen al día con la información de tu producto.
+
+
+ ### Tabla de contenidos
+
+
+Cada propiedad `label` de un `Update` crea automáticamente una entrada en la tabla de contenidos de la barra lateral derecha. Esta es la navegación predeterminada de tu registro de cambios.
+
+
+ 
+
+ 
+
+
+
+ ### Filtros por etiquetas
+
+
+Agrega `tags` a tus componentes `Update` para sustituir la tabla de contenidos por filtros de etiquetas. Los usuarios pueden filtrar el registro de cambios seleccionando una o más etiquetas:
+
+```mdx Ejemplo de ajuste de filtros por etiquetas
+
+
+ 
+
+
+
+ ### Registros de cambios con suscripción
+
+
+Usar componentes `Update` crea un feed RSS al que te puedes suscribir en la URL de tu página con `/rss.xml` agregado. Por ejemplo, `mintlify.com/docs/changelog/rss.xml`.
+
+Las entradas se agregan al feed RSS cuando se publican nuevos componentes `Update` y cuando se agregan nuevos encabezados dentro de etiquetas `
+
+ 
+
diff --git a/es/guides/claude-code.mdx b/es/guides/claude-code.mdx
new file mode 100644
index 000000000..3f9982bd2
--- /dev/null
+++ b/es/guides/claude-code.mdx
@@ -0,0 +1,179 @@
+---
+title: "Claude Code"
+description: "Configura Claude Code para ayudar a escribir, revisar y actualizar tu documentación"
+icon: "asterisk"
+---
+
+Claude Code es una herramienta de línea de comandos con capacidades de agente que puede ayudarte a mantener tu documentación. Puede redactar contenido nuevo, revisar páginas existentes y mantener la documentación al día.
+
+Puedes entrenar a Claude Code para que comprenda tus estándares y flujos de trabajo de documentación añadiendo un archivo `CLAUDE.md` a tu proyecto y afinándolo con el tiempo.
+
+
+
+
+ ## Primeros pasos
+
+
+**Requisitos previos:**
+
+* Suscripción activa a Claude (Pro, Max o acceso mediante API)
+
+**Configuración:**
+
+1. Instala Claude Code:
+
+```bash
+npm install -g @anthropic-ai/claude-code
+```
+
+2. Ve al directorio de tus docs.
+3. (Opcional) Añade el archivo `CLAUDE.md` que aparece a continuación a tu proyecto.
+4. Ejecuta `claude` para empezar.
+
+
+
+ ## Plantilla de CLAUDE.md
+
+
+Guarda un archivo `CLAUDE.md` en la raíz de tu directorio de documentación para ayudar a Claude Code a comprender tu proyecto. Este archivo entrena a Claude Code en tus estándares de documentación, preferencias y flujos de trabajo. Consulta [Manage Claude's memory](https://docs.anthropic.com/en/docs/claude-code/memory) en la documentación de Anthropic para obtener más información.
+
+Copia esta plantilla de ejemplo o ajústala según las especificaciones de tu documentación:
+
+```mdx
+# Documentación de Mintlify
+
+## Relación de trabajo
+- Puedes cuestionar ideas; esto puede llevar a una mejor documentación. Cita fuentes y explica tu razonamiento cuando lo hagas
+- SIEMPRE pide aclaraciones en lugar de hacer suposiciones
+- NUNCA mientas, adivines ni inventes información
+
+## Contexto del proyecto
+- Formato: archivos MDX con frontmatter YAML
+- Configuración: docs.json para navegación, tema y ajustes
+- Componentes: componentes de Mintlify
+
+## Estrategia de contenido
+- Documenta lo suficiente para el éxito del usuario: ni demasiado ni demasiado poco
+- Prioriza la precisión y la utilidad de la información
+- Haz el contenido perenne cuando sea posible
+- Busca información existente antes de añadir contenido nuevo. Evita la duplicación salvo por un motivo estratégico
+- Revisa los patrones existentes para mantener la coherencia
+- Empieza realizando los cambios razonables más pequeños
+
+## docs.json
+
+- Consulta el [esquema de docs.json](https://mintlify.com/docs.json) al crear el archivo docs.json y la navegación del sitio
+
+## Requisitos de frontmatter para páginas
+- title: Título claro y descriptivo de la página
+- description: Resumen conciso para SEO/navegación
+
+## Estándares de redacción
+- Voz en segunda persona ("tú")
+- Prerrequisitos al inicio del contenido procedimental
+- Prueba todos los ejemplos de código antes de publicar
+- Adapta el estilo y formato al de las páginas existentes
+- Incluye casos de uso básicos y avanzados
+- Etiquetas de idioma en todos los bloques de código
+- Texto alternativo en todas las imágenes
+- Rutas relativas para los enlaces internos
+
+## Flujo de trabajo con Git
+- NUNCA uses --no-verify al hacer commits
+- Pregunta cómo manejar los cambios no confirmados antes de empezar
+- Crea una nueva rama cuando no exista una rama clara para los cambios
+- Haz commits con frecuencia durante el desarrollo
+- NUNCA omitas ni desactives los hooks de pre-commit
+
+## No hacer
+- Omitir el frontmatter en cualquier archivo MDX
+- Usar URL absolutas para enlaces internos
+- Incluir ejemplos de código no probados
+- Hacer suposiciones: siempre pide aclaraciones
+```
+
+
+
+ ## Prompts de ejemplo
+
+
+Una vez que tengas configurado Claude Code, prueba estos prompts para ver cómo puede ayudar con tareas comunes de documentación. Puedes copiar y pegar estos ejemplos directamente o adaptarlos a tus necesidades específicas.
+
+
+ ### Convertir notas en documentación de calidad
+
+
+Convierte borradores en páginas Markdown bien estructuradas, con componentes y frontmatter.
+
+**Prompt de ejemplo:**
+
+```text ajustar
+Convierte este texto en una página MDX con el formato correcto: [pega tu texto aquí]
+```
+
+
+ ### Revisar la documentación en busca de coherencia
+
+
+Obtén sugerencias para mejorar el estilo, el formato y el uso de componentes.
+
+**Ejemplo de indicación:**
+
+```text ajustar
+Revisa los archivos en docs/ y sugiere mejoras para mejorar la consistencia y la claridad
+```
+
+
+ ### Actualiza la documentación cuando cambien las funcionalidades
+
+
+Mantén la documentación al día a medida que tu producto evoluciona.
+
+**Ejemplo de prompt:**
+
+```text ajustar
+Nuestra API ahora requiere un parámetro de versión. Actualiza nuestra documentación para incluir version=2024-01 en todos los ejemplos
+```
+
+
+ ### Genera ejemplos de código completos
+
+
+Crea ejemplos en varios lenguajes con manejo de errores.
+
+**Ejemplo de prompt:**
+
+```text ajustar
+Crea ejemplos de código para [tu endpoint de API] en JavaScript, Python y cURL con gestión de errores
+```
+
+
+
+ ## Extender Claude Code
+
+
+Además de interactuar manualmente con Claude Code, puedes integrarlo en tus flujos de trabajo existentes.
+
+
+ ### Automatización con GitHub Actions
+
+
+Ejecuta Claude Code automáticamente cuando haya cambios en el código para mantener la documentación al día. Puedes activar revisiones de documentación en pull requests o actualizar ejemplos cuando se detecten cambios en la API.
+
+
+ ### Flujos de trabajo con múltiples instancias
+
+
+Usa sesiones separadas de Claude Code para distintas tareas: una para redactar contenido nuevo y otra para revisión y aseguramiento de la calidad. Esto ayuda a mantener la coherencia y a detectar problemas que una sola sesión podría pasar por alto.
+
+
+ ### Colaboración en equipo
+
+
+Comparte tu archivo `CLAUDE.md` refinado con tu equipo para garantizar estándares de documentación consistentes entre todos los colaboradores. Los equipos suelen desarrollar prompts y flujos de trabajo específicos del proyecto que pasan a formar parte de su proceso de documentación.
+
+
+ ### Comandos personalizados
+
+
+Crea comandos reutilizables con barra en `.claude/commands/` para tareas de documentación frecuentes específicas de tu proyecto o equipo.
diff --git a/es/guides/csp-configuration.mdx b/es/guides/csp-configuration.mdx
new file mode 100644
index 000000000..24e22ce83
--- /dev/null
+++ b/es/guides/csp-configuration.mdx
@@ -0,0 +1,157 @@
+---
+title: "Configuración de Content Security Policy (CSP)"
+sidebarTitle: "Configuración de CSP"
+description: "Lista de dominios permitidos y configuración de encabezados para proxies inversos, firewalls y redes que aplican políticas de seguridad estrictas"
+---
+
+Content Security Policy (CSP) es un estándar de seguridad que ayuda a prevenir ataques de cross-site scripting (XSS) al controlar qué recursos puede cargar una página web. Mintlify sirve una CSP predeterminada que protege a la mayoría de los sitios. Si alojas tu documentación detrás de un proxy inverso o firewall que sobrescribe la CSP predeterminada, es posible que debas configurar los encabezados CSP para que las funciones operen correctamente.
+
+
+ ## Directivas CSP
+
+
+Las siguientes directivas de CSP se utilizan para controlar qué recursos se pueden cargar:
+
+- `script-src`: Controla qué scripts se pueden ejecutar
+- `style-src`: Controla qué hojas de estilo se pueden cargar
+- `font-src`: Controla qué fuentes se pueden cargar
+- `img-src`: Controla qué imágenes, iconos y logotipos se pueden cargar
+- `connect-src`: Controla con qué URLs se puede establecer conexión para llamadas de API y conexiones WebSocket
+- `frame-src`: Controla qué URLs se pueden incrustar en marcos o iframes
+- `default-src`: Valor predeterminado para otras directivas cuando no se establece explícitamente
+
+
+ ## Lista de permitidos de dominios
+
+
+| Dominio | Propósito | Directiva CSP | Obligatorio |
+|:-------|:--------|:--------------|:-------|
+| `d4tuoctqmanu0.cloudfront.net` | CSS y fuentes de KaTeX | `style-src`, `font-src` | Obligatorio |
+| `*.mintlify.dev` | Contenido de documentación | `connect-src`, `frame-src` | Obligatorio |
+| `*.mintlify.com` | Panel, API, proxy de analíticas | `connect-src` | Obligatorio |
+| `leaves.mintlify.com` | API del Asistente | `connect-src` | Obligatorio |
+| `d3gk2c5xim1je2.cloudfront.net` | Iconos, imágenes, logotipos | `img-src` | Obligatorio |
+| `d1ctpt7j8wusba.cloudfront.net` | Archivos de versiones y lanzamientos de Mint | `connect-src` | Obligatorio |
+| `mintcdn.com` | Imágenes, favicons | `img-src`, `connect-src` | Obligatorio |
+| `*.mintcdn.com` | Imágenes, favicons | `img-src`, `connect-src` | Obligatorio |
+| `api.mintlifytrieve.com` | API de búsqueda | `connect-src` | Obligatorio |
+| `cdn.jsdelivr.net` | Recursos de emoji para imágenes OG | `script-src`, `img-src` | Obligatorio |
+| `fonts.googleapis.com` | Google Fonts | `style-src`, `font-src` | Opcional |
+| `www.googletagmanager.com` | Google Analytics/GTM | `script-src`, `connect-src` | Opcional |
+| `cdn.segment.com` | Analíticas de Segment | `script-src`, `connect-src` | Opcional |
+| `plausible.io` | Analíticas de Plausible | `script-src`, `connect-src` | Opcional |
+| `us.posthog.com` | Analíticas de PostHog | `connect-src` | Opcional |
+| `cdn.getkoala.com` | Analíticas de Koala | `script-src` | Opcional |
+| `tag.clearbitscripts.com` | Seguimiento de Clearbit | `script-src` | Opcional |
+| `cdn.heapanalytics.com` | Analíticas de Heap | `script-src` | Opcional |
+| `chat.cdn-plain.com` | Widget de chat de Plain | `script-src` | Opcional |
+| `chat-assets.frontapp.com` | Widget de chat de Front | `script-src` | Opcional |
+| `browser.sentry-cdn.com` | Seguimiento de errores de Sentry | `script-src`, `connect-src` | Opcional |
+| `js.sentry-cdn.com` | SDK de JavaScript de Sentry | `script-src` | Opcional |
+
+
+ ## Ejemplo de configuración de CSP
+
+
+
+ ## Configuraciones comunes por tipo de proxy
+
+
+La mayoría de los proxies inversos permiten añadir encabezados personalizados.
+
+
+ ### Configuración de Cloudflare
+
+
+Crea una regla de transformación de encabezados de respuesta:
+
+1. En tu panel de Cloudflare, ve a **Rules > Overview**.
+2. Selecciona **Create rule > Response Header Transform Rule**.
+3. Configura la regla:
+
+- **Modify response header**: Fijar estático
+ - **Header name**: `Content-Security-Policy`
+ - **Header value**:
+ ```text wrap
+ default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' cdn.jsdelivr.net; style-src 'self' 'unsafe-inline' d4tuoctqmanu0.cloudfront.net fonts.googleapis.com; font-src 'self' d4tuoctqmanu0.cloudfront.net fonts.googleapis.com; img-src 'self' data: blob: d3gk2c5xim1je2.cloudfront.net mintcdn.com *.mintcdn.com cdn.jsdelivr.net; connect-src 'self' *.mintlify.dev *.mintlify.com d1ctpt7j8wusba.cloudfront.net mintcdn.com *.mintcdn.com api.mintlifytrieve.com; frame-src 'self' *.mintlify.dev;
+ ```
+
+4. Implementa la regla.
+
+
+ ### Configuración de AWS CloudFront
+
+
+Añade una política de encabezados de respuesta en CloudFront:
+
+```json
+{
+"ResponseHeadersPolicy": {
+ "Name": "MintlifyCSP",
+ "Config": {
+ "SecurityHeadersConfig": {
+ "ContentSecurityPolicy": {
+ "ContentSecurityPolicy": "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' cdn.jsdelivr.net; style-src 'self' 'unsafe-inline' d4tuoctqmanu0.cloudfront.net fonts.googleapis.com; font-src 'self' d4tuoctqmanu0.cloudfront.net fonts.googleapis.com; img-src 'self' data: blob: d3gk2c5xim1je2.cloudfront.net mintcdn.com *.mintcdn.com cdn.jsdelivr.net; connect-src 'self' *.mintlify.dev *.mintlify.com d1ctpt7j8wusba.cloudfront.net mintcdn.com *.mintcdn.com api.mintlifytrieve.com; frame-src 'self' *.mintlify.dev;",
+ "Override": true
+ }
+ }
+ }
+ }
+}
+```
+
+
+
+ ### Configuración de Vercel
+
+
+Agrega lo siguiente a tu `vercel.json`:
+
+```json
+{
+"headers": [
+ {
+ "source": "/(.*)",
+ "headers": [
+ {
+ "key": "Content-Security-Policy",
+ "value": "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' cdn.jsdelivr.net; style-src 'self' 'unsafe-inline' d4tuoctqmanu0.cloudfront.net fonts.googleapis.com; font-src 'self' d4tuoctqmanu0.cloudfront.net fonts.googleapis.com; img-src 'self' data: blob: d3gk2c5xim1je2.cloudfront.net mintcdn.com *.mintcdn.com cdn.jsdelivr.net; connect-src 'self' *.mintlify.dev *.mintlify.com d1ctpt7j8wusba.cloudfront.net mintcdn.com *.mintcdn.com api.mintlifytrieve.com; frame-src 'self' *.mintlify.dev;"
+ }
+ ]
+ }
+ ]
+}
+```
+
+
+
+ ## Solución de problemas
+
+
+Identifica infracciones de CSP en la consola de tu navegador:
+
+1. Abre las herramientas de desarrollador de tu navegador.
+2. Ve a la pestaña **Console**.
+3. Busca errores que comiencen con:
+ - `Content Security Policy: The page's settings blocked the loading of a resource`
+ - `Refused to load the script/stylesheet because it violates the following Content Security Policy directive`
+ - `Refused to connect to because it violates the following Content Security Policy directive`
\ No newline at end of file
diff --git a/es/guides/cursor.mdx b/es/guides/cursor.mdx
new file mode 100644
index 000000000..f2c5abdbc
--- /dev/null
+++ b/es/guides/cursor.mdx
@@ -0,0 +1,445 @@
+---
+title: "Cursor"
+description: "Configura Cursor como tu asistente de redacción"
+icon: "box"
+---
+
+Convierte a Cursor en un experto en documentación que conozca tus componentes, tu guía de estilo y tus mejores prácticas.
+
+
+
+
+ ## Usar Cursor con Mintlify
+
+
+Las reglas de Cursor proporcionan contexto persistente sobre tu documentación, lo que garantiza sugerencias más coherentes y alineadas con tus estándares y estilo.
+
+* **Reglas de proyecto**: se almacenan en el repositorio de tu documentación y se comparten con tu equipo.
+* **Reglas de usuario**: se aplican a tu entorno personal de Cursor.
+
+Recomendamos crear reglas de proyecto para tu documentación, de modo que todas las personas colaboradoras tengan acceso a las mismas reglas.
+
+Crea archivos de reglas en el directorio `.cursor/rules` del repositorio de tu documentación. Consulta la [documentación de Cursor Rules](https://docs.cursor.com/context/rules) para ver las instrucciones completas de configuración.
+
+
+
+
+ ## Regla de proyecto de ejemplo
+
+
+Esta regla ofrece a Cursor el contexto necesario para formatear correctamente los componentes de Mintlify y seguir las mejores prácticas de redacción técnica.
+
+Puedes usar este ejemplo tal cual o personalizarlo para tu documentación:
+
+* **Estándares de redacción**: Actualiza las pautas lingüísticas para que se ajusten a tu guía de estilo.
+* **Patrones de componentes**: Añade componentes específicos del proyecto o modifica los ejemplos existentes.
+* **Ejemplos de código**: Sustituye los ejemplos genéricos por llamadas y respuestas reales de la API de tu producto.
+* **Preferencias de estilo y tono**: Ajusta la terminología, el formato y otras reglas.
+
+Añade esta regla, con cualquier modificación, como un archivo `.mdc` en el directorio `.cursor/rules` de tu repositorio de documentación.
+
+
+
+````mdx envolver
+# Regla de redacción técnica de Mintlify
+
+Eres un asistente de redacción con IA especializado en crear documentación técnica excepcional usando componentes de Mintlify y siguiendo prácticas líderes de redacción técnica en la industria.
+
+## Principios básicos de redacción
+
+### Requisitos de lenguaje y estilo
+
+- Usa un lenguaje claro y directo, apropiado para audiencias técnicas
+- Escribe en segunda persona ("tú") para instrucciones y procedimientos
+- Prefiere la voz activa sobre la pasiva
+- Emplea el presente para estados actuales y el futuro para resultados
+- Evita la jerga salvo que sea necesaria y define los términos la primera vez que se usen
+- Mantén una terminología consistente en toda la documentación
+- Mantén oraciones concisas y proporciona el contexto necesario
+- Usa estructuras paralelas en listas, encabezados y procedimientos
+
+### Estándares de organización del contenido
+
+- Comienza con la información más importante (estructura de pirámide invertida)
+- Aplica divulgación progresiva: conceptos básicos antes que los avanzados
+- Divide los procedimientos complejos en pasos numerados
+- Incluye prerrequisitos y contexto antes de las instrucciones
+- Indica los resultados esperados para cada paso principal
+- Usa encabezados descriptivos y ricos en palabras clave para navegación y SEO
+- Agrupa la información relacionada de forma lógica con separaciones claras de sección
+
+### Enfoque centrado en el usuario
+
+- Enfócate en los objetivos y resultados del usuario en lugar de las funciones del sistema
+- Anticipa preguntas comunes y abórdalas proactivamente
+- Incluye solución de problemas para puntos de fallo probables
+- Optimiza para lectura en diagonal con encabezados claros, listas y espacios en blanco
+- Incluye pasos de verificación para confirmar el éxito
+
+## Referencia de componentes de Mintlify
+
+### docs.json
+
+- Consulta el [esquema de docs.json](https://mintlify.com/docs.json) al crear el archivo docs.json y la navegación del sitio
+
+### Componentes de aviso
+
+#### Nota - Información adicional útil
+
+
+
+
+
+
+
+
+#### Videos
+
+Usa el elemento de video HTML para contenido de video autoalojado:
+
+
+
+Incorpora videos de YouTube usando elementos iframe:
+
+
+
+#### Tooltips
+
+Ejemplo de uso de tooltip:
+
+
+ ## Activar un despliegue manualmente
+
+
+
+
+ 
+
+
+ ## Inicio rápido de GEO
+
+
+
+ ### Configuración inicial
+
+
+1. **Asegúrate de que tu documentación esté siendo indexada** en la configuración de tu `docs.json`
+2. **Audita las páginas actuales** para detectar títulos y descripciones faltantes
+
+
+ ### Mejoras de contenido
+
+
+1. **Agrega tablas comparativas** a las páginas correspondientes
+2. **Audita los encabezados** para asegurarte de que respondan preguntas comunes
+3. **Mejora los enlaces internos** entre temas relacionados
+4. **Prueba con herramientas de IA** para verificar la exactitud
+
+
+
+
+ ## Mejores prácticas de GEO
+
+
+En general, la documentación bien escrita y bien estructurada tendrá un GEO sólido. Aun así, prioriza escribir para tus usuarios y, si tu contenido satisface sus necesidades, estarás bien encaminado para optimizarlo para herramientas de IA. Crear contenido realmente útil, en lugar de optimizar por optimizar, es recompensado tanto por los motores de búsqueda tradicionales como por los de IA.
+
+Enfócate en:
+
+- Contenido alineado con las necesidades del usuario en lugar de la coincidencia de palabras clave
+- Información estructurada y fácil de recorrer de un vistazo
+- Respuestas directas a preguntas
+
+
+ ### Formato para mayor claridad
+
+
+Estas prácticas de formato ayudan a las herramientas de IA a analizar y comprender tu contenido:
+
+- No te saltes niveles de encabezado (H1 → H2 → H3)
+- Usa nombres de objetos específicos en lugar de “it” o “this”
+- Etiqueta los bloques de código con su lenguaje de programación
+- Proporciona texto alternativo descriptivo para las imágenes
+- Enlaza a conceptos relacionados para ayudar a la IA a comprender las relaciones
+
+
+ ### Responde preguntas directamente
+
+
+Escribe contenido que aborde preguntas específicas de los usuarios:
+
+- Comienza las secciones con la idea principal
+- Usa encabezados descriptivos que coincidan con consultas comunes
+- Divide los temas complejos en pasos numerados
+
+
+
+
+ ## Configuración de Mintlify
+
+
+Utiliza estas funciones para mejorar la GEO.
+
+
+ ### Agrega metadatos descriptivos de la página
+
+
+Incluye títulos y descripciones claros en el frontmatter:
+
+```mdx
+---
+title: "Guía de autenticación de API"
+description: "Guía completa para implementar la autenticación de API con ejemplos de código"
+---
+```
+
+
+ ### Configura la configuración global de indexación
+
+
+Agrega lo siguiente a tu `docs.json`:
+
+```json
+{
+ "seo": {
+ "indexing": "all",
+ "metatags": {
+ "og:type": "website",
+ "og:site_name": "Tu documentación"
+ }
+ }
+}
+```
+
+
+ ### LLMs.txt
+
+
+Los archivos LLMs.txt ayudan a los sistemas de IA a entender la estructura de tu documentación, de forma similar a como los sitemaps ayudan a los motores de búsqueda. Mintlify genera automáticamente archivos LLMs.txt para tu documentación. No se requiere configuración.
+
+
+
+ ## Prueba de tu documentación
+
+
+Evalúa varias herramientas de IA con preguntas sobre tu producto y tu documentación para ver qué tan bien citan tus docs.
+
+**Haz a los asistentes de IA preguntas específicas sobre tus docs:**
+- "¿Cómo configuro la autenticación con esta API?"
+- "Guíame paso a paso por el proceso de instalación"
+
+**Comprueba que las herramientas ofrezcan:**
+- Ejemplos de código correctos
+- Instrucciones precisas paso a paso
diff --git a/es/guides/hidden-page-example.mdx b/es/guides/hidden-page-example.mdx
new file mode 100644
index 000000000..aa452590c
--- /dev/null
+++ b/es/guides/hidden-page-example.mdx
@@ -0,0 +1,61 @@
+---
+title: "Ejemplo de página oculta"
+description: "Casos de uso comunes de las páginas ocultas"
+icon: "eye-off"
+---
+
+¡Esta página está oculta! No aparece en la navegación de `docs.json`, por lo que solo puedes acceder a ella mediante su URL.
+
+Consulta [Páginas ocultas](/es/guides/hidden-pages) para más información.
+
+
+
+
+ ## Ejemplos
+
+
+
+ ### Contexto de IA
+
+
+```mdx ajustar
+---
+title: "Contexto para la versión de la API"
+description: "Esta página proporciona contexto para que las herramientas de IA respondan a preguntas sobre versiones de la API"
+---
+
+Cuando un usuario pregunte sobre versiones de la API, recomienda siempre usar la versión más reciente. Nunca generes respuestas para versiones anteriores a la 1.0.4.
+```
+
+
+ ### Endpoint de API interna
+
+
+````mdx envolver
+---
+title: "Endpoint interno de la API"
+description: "Esta es una página oculta que documenta un endpoint interno de la API"
+---
+
+```bash
+POST /api/internal/reset-cache
+Authorization: Bearer internal-token-xyz
+```
+
+Este endpoint limpia la caché de la aplicación y solo está disponible en entornos de desarrollo.
+
+
+ ## Ocultar una página
+
+
+Una página está oculta si no está incluida en la navegación de tu `docs.json`. Para ocultar una página, quítala de tu estructura de navegación.
+
+Las páginas ocultas usan la misma estructura de URL que las páginas normales según su ruta de archivo. Por ejemplo, `guides/hidden-page.mdx` sería accesible en `docs.yoursite.com/guides/hidden-page`.
+
+Consulta un [ejemplo de página oculta](/es/guides/hidden-page-example).
+
+
+ ## Ocultar un grupo de páginas
+
+
+Un grupo de páginas se oculta si la propiedad `hidden` está configurada en `true` en tu archivo `docs.json`:
+
+```json highlight={4}
+"groups": [
+ {
+ "group": "Primeros pasos",
+ "hidden": true,
+ "pages": [
+ "index",
+ "quickstart"
+ ]
+ },
+ {
+ "group": "Guías",
+ "pages": [
+ "guides/hidden-page.mdx",
+ "guides/hidden-groups.mdx"
+ ]
+ }
+]
+```
+
+En este ejemplo, el grupo `Getting started` está oculto, pero el grupo `Guides` está visible.
+
+
+ ### Ocultar una pestaña
+
+
+También puedes ocultar una pestaña añadiendo la propiedad `hidden` a tu archivo `docs.json`:
+
+```json highlight={4}
+"tabs": [
+ {
+ "tab": "Inicio",
+ "hidden": true,
+ "pages": [
+ "index",
+ "quickstart"
+ ]
+ }
+]
+```
+
+
+ ## Búsqueda, SEO e indexación con IA
+
+
+De forma predeterminada, las páginas ocultas se excluyen de la indexación para los motores de búsqueda, la búsqueda interna de tu documentación y como contexto para el Asistente de IA. Para incluir páginas ocultas en los resultados de búsqueda y como contexto para el Asistente, agrega la propiedad `seo` a tu `docs.json`:
+
+```json
+"seo": {
+ "indexing": "all"
+}
+```
+
+Para excluir una página específica, agrega `noindex: true` a su front matter.
diff --git a/es/guides/migration.mdx b/es/guides/migration.mdx
new file mode 100644
index 000000000..4ad85c106
--- /dev/null
+++ b/es/guides/migration.mdx
@@ -0,0 +1,201 @@
+---
+title: "Migraciones"
+description: "Cómo migrar la documentación desde tu plataforma actual"
+icon: "import"
+---
+
+Esta guía te ayuda a trasladar tu documentación existente a Mintlify. Elige la migración automatizada para las plataformas compatibles o la migración manual para tener control total sobre el proceso.
+
+
+ ## Elige tu ruta de migración
+
+
+
+ ## Lista de verificación posterior a la migración
+
+
+Después de completar tu migración (automatizada o manual), te recomendamos verificar:
+
+* Todas las páginas se renderizan
+* La navegación funciona como se espera
+* Los enlaces internos funcionan correctamente
+* Las imágenes y los recursos cargan correctamente
+* Los bloques de código muestran el resaltado de sintaxis correcto
+* La búsqueda funciona
+* El despliegue está configurado
+* El dominio personalizado está configurado
diff --git a/es/guides/monorepo.mdx b/es/guides/monorepo.mdx
new file mode 100644
index 000000000..1b081ce25
--- /dev/null
+++ b/es/guides/monorepo.mdx
@@ -0,0 +1,51 @@
+---
+title: "Configuración de monorepo"
+description: "Despliega tu documentación desde un repositorio que contiene múltiples proyectos"
+icon: "folder-git"
+---
+
+Configura Mintlify para desplegar la documentación desde un directorio específico dentro de un monorepo. Esta configuración te permite mantener la documentación junto a tu código en repositorios que contienen múltiples proyectos o servicios.
+
+
+
+
+ ## Requisitos previos
+
+
+* Acceso de administrador a tu proyecto de Mintlify.
+* Archivos de documentación organizados en un directorio dedicado dentro de tu monorepo.
+* Un `docs.json` válido en tu directorio de documentación.
+
+
+
+
+ ## Configurar la implementación de un monorepo
+
+
+
+
+
+
+
+ ## Configuración de enrutamiento
+
+
+Redirige estas rutas a tu subdominio de Mintlify con las siguientes políticas de caché:
+
+| Ruta | Destino | Caché |
+|------|-------------|---------|
+| `/.well-known/acme-challenge/*` | `
+ ## Configuración requerida de encabezados
+
+
+Configura tu proxy inverso con estos requisitos de encabezados:
+
+- **Origin**: Contiene el subdominio de destino `
+ ## Ejemplo de configuración de Nginx
+
+
+```nginx
+server {
+ listen 80;
+ server_name
+ ## Solución de problemas
+
+
+
+ ### Error 404
+
+
+**Síntomas**: La documentación se carga, pero las funcionalidades no funcionan. Las llamadas a la API fallan.
+
+**Causa**: Se está reenviando el encabezado `Host` o falta el encabezado `Origin`.
+
+**Solución**:
+
+- Eliminar el reenvío del encabezado `Host`
+- Establecer el encabezado `Origin` en `
+ ### Problemas de rendimiento
+
+
+**Síntomas**: Carga lenta de páginas y desplazamientos del diseño.
+
+**Causa**: Configuración de caché incorrecta.
+
+**Solución**: Habilita la caché solo para las rutas `/mintlify-assets/_next/static/*`.
\ No newline at end of file
diff --git a/es/guides/windsurf.mdx b/es/guides/windsurf.mdx
new file mode 100644
index 000000000..d7dc0c99e
--- /dev/null
+++ b/es/guides/windsurf.mdx
@@ -0,0 +1,156 @@
+---
+title: "Windsurf"
+description: "Configura Windsurf para que sea tu asistente de escritura"
+icon: "waves"
+---
+
+Convierte Windsurf en un experto en documentación que comprende tu guía de estilo, tus componentes y el contexto de tu proyecto mediante reglas del espacio de trabajo y memorias.
+
+
+
+
+ ## Usar Windsurf con Mintlify
+
+
+El Asistente de IA Cascade de Windsurf se puede ajustar para redactar documentación conforme a tus estándares utilizando componentes de Mintlify. Las reglas del espacio de trabajo y las memorias proporcionan contexto persistente sobre tu proyecto, lo que garantiza sugerencias más coherentes de Cascade.
+
+* **Reglas del espacio de trabajo**: se almacenan en tu repositorio de documentación y se comparten con tu equipo.
+* **Memorias**: proporcionan contexto individual que se acumula con el tiempo.
+
+Recomendamos configurar reglas del espacio de trabajo para definir estándares de documentación compartidos. Puedes desarrollar memorias a medida que trabajas, pero como no se comparten, no serán coherentes entre los miembros del equipo.
+
+Crea reglas del espacio de trabajo en el directorio `.windsurf/rules` de tu repositorio de documentación. Consulta [Memories & Rules](https://docs.windsurf.com/windsurf/cascade/memories) en la documentación de Windsurf para obtener más información.
+
+
+
+
+ ## Regla de espacio de trabajo de ejemplo
+
+
+Esta regla proporciona a Cascade contexto sobre los componentes de Mintlify y las mejores prácticas generales de documentación técnica.
+
+Puedes usar esta regla de ejemplo tal como está o personalizarla para tu documentación:
+
+* **Estándares de redacción**: Actualiza las pautas de lenguaje para alinearlas con tu guía de estilo.
+* **Patrones de componentes**: Añade componentes específicos del proyecto o modifica los ejemplos existentes.
+* **Ejemplos de código**: Sustituye los ejemplos genéricos por llamadas y respuestas reales de tu API para tu producto.
+* **Preferencias de estilo y tono**: Ajusta la terminología, el formato y otras reglas.
+
+Guarda la regla como un archivo `.md` en el directorio `.windsurf/rules` del repositorio de tu documentación.
+
+````mdx
+# Norma de redacción técnica de Mintlify
+
+## Contexto del proyecto
+
+- Este es un proyecto de documentación en la plataforma Mintlify
+- Usamos archivos MDX con frontmatter en YAML
+- La navegación se configura en `docs.json`
+- Seguimos las mejores prácticas de redacción técnica
+
+## Estándares de redacción
+
+- Usa la segunda persona ("tú") para las instrucciones
+- Escribe en voz activa y en tiempo presente
+- Inicia los procedimientos con requisitos previos
+- Incluye los resultados esperados para los pasos principales
+- Usa encabezados descriptivos y con palabras clave
+- Mantén las frases concisas pero informativas
+
+## Estructura de página requerida
+
+Cada página debe comenzar con frontmatter:
+
+```yaml
+---
+title: "Título claro y específico"
+description: "Descripción concisa para SEO y la navegación"
+---
+```
+
+## Componentes de Mintlify
+
+### docs.json
+
+- Consulta el [esquema de docs.json](https://mintlify.com/docs.json) al crear el archivo docs.json y la navegación del sitio
+
+### Avisos
+
+- `
+ ## Trabajar con Cascade
+
+
+Una vez que hayas configurado tus reglas, puedes usar Cascade para ayudarte con diversas tareas de documentación. Consulta [Cascade](https://docs.windsurf.com/windsurf/cascade) en la documentación de Windsurf para obtener más información.
+
+
+ ### Ejemplos de prompts
+
+
+**Redacción de contenido nuevo**:
+
+```text ajustar
+Crea una nueva página que explique cómo autenticarse en nuestra API. Incluye ejemplos de código en JavaScript, Python y cURL.
+```
+
+**Mejorar el contenido existente**:
+
+```text ajuste
+Revisa esta página y sugiere mejoras para la claridad y el uso de componentes. Concéntrate en que los pasos sean más fáciles de seguir.
+```
+
+**Creación de ejemplos de código**:
+
+```text ajustar
+Genera un ejemplo de código completo que muestre el manejo de errores para este endpoint de API. Usa datos realistas e incluye las respuestas esperadas.
+```
+
+**Mantener la consistencia**:
+
+```text ajustar
+Verifica si esta nueva página cumple con nuestros estándares de documentación y sugiere los cambios necesarios.
+```
diff --git a/es/image-embeds.mdx b/es/image-embeds.mdx
new file mode 100644
index 000000000..e1823a748
--- /dev/null
+++ b/es/image-embeds.mdx
@@ -0,0 +1,196 @@
+---
+title: "Imágenes y contenido incrustado"
+description: "Añade imágenes, videos e iframes"
+icon: "image"
+---
+
+Añade imágenes, incrusta videos e incluye contenido interactivo con iframes en tu documentación.
+
+Todos los archivos estáticos de tu repositorio de documentación se sirven automáticamente en la ruta correspondiente de tu dominio. Por ejemplo, si tienes `/images/my-logo.png` en tu repo, la imagen estará disponible en `https://docs.yoursite.com/images/my-logo.png`.
+
+
+ 
+
+
+
+ ## Imágenes
+
+
+Añade imágenes para aportar contexto visual, ejemplos o elementos decorativos a tu documentación.
+
+
+ ### Sintaxis básica de imágenes
+
+
+Usa la [sintaxis de Markdown](https://www.markdownguide.org/basic-syntax/#images) para agregar imágenes a tu documentación:
+
+```mdx
+
+```
+
+
+ ### Inserciones de imágenes en HTML
+
+
+Para tener más control sobre la visualización de imágenes, usa etiquetas `
+```
+
+
+ #### Desactivar la funcionalidad de zoom
+
+
+Para desactivar el zoom predeterminado al hacer clic en las imágenes, agrega la propiedad `noZoom`:
+
+```html highlight="4"
+
+```
+
+
+ #### Enlazar imágenes
+
+
+Para convertir una imagen en un enlace clicable, envuelve la imagen en una etiqueta de enlace (anchor) y agrega la propiedad `noZoom`:
+
+```html
+
+ 
+
+```
+
+
+ #### Imágenes para modos claro y oscuro
+
+
+Para mostrar imágenes distintas en los temas claro y oscuro, usa clases de Tailwind CSS:
+
+```html
+
+
+
+
+
+```
+
+
+ ## Videos
+
+
+Mintlify admite [etiquetas HTML en Markdown](https://www.markdownguide.org/basic-syntax/#html), lo que te da flexibilidad para crear contenido enriquecido.
+
+
+ ### Insertar contenido de YouTube
+
+
+Inserta videos de YouTube usando elementos iframe:
+
+```html
+
+```
+
+
+
+
+
+
+ ### Videos autoalojados
+
+
+Usa el elemento HTML `