diff --git a/ai/skillmd.mdx b/ai/skillmd.mdx
index 605cd4baf0..074f3db84f 100644
--- a/ai/skillmd.mdx
+++ b/ai/skillmd.mdx
@@ -152,6 +152,17 @@ Group-gated skills are:
Skills without a `groups` field remain visible to everyone.
+### Validate a custom skill file
+
+Before deploying, verify that your custom skill files are valid:
+
+- **Check the frontmatter.** Every custom skill file must start with YAML frontmatter that includes at least a `name` and a `description`. See [Frontmatter fields](#frontmatter-fields) for the full list of supported fields.
+- **Preview locally.** Run [`mint dev`](/organize/settings) to serve your site locally, then open `http://localhost:3000/skill.md` to check that your custom file loads instead of the generated one.
+- **Verify after deploying.** After your site deploys, append `/skill.md` to your site's URL to view the served skill file. For multiple skills, fetch `/.well-known/agent-skills/index.json` to confirm each custom skill appears in the discovery manifest.
+- **Validate against the specification.** Compare your file against the [agentskills.io specification](https://agentskills.io/specification) to confirm required sections are present and formatted correctly.
+
+Changes to custom skill files publish with your next deployment. Because generated skills can take up to 24 hours to update, custom skills are the fastest way to control what agents see.
+
## Skills discovery endpoints
Mintlify hosts skills directories at `/.well-known/skills/` and `/.well-known/agent-skills/` that agents can use to discover and fetch your skill files programmatically.
diff --git a/api-playground/troubleshooting.mdx b/api-playground/troubleshooting.mdx
index 90d041a102..9945a44516 100644
--- a/api-playground/troubleshooting.mdx
+++ b/api-playground/troubleshooting.mdx
@@ -77,6 +77,22 @@ If your API pages aren't displaying correctly, check these common configuration
Alternatively, if your reverse proxy prevents you from accepting `POST` requests, you can configure Mintlify to send requests directly to your backend with the `api.playground.proxy` setting in the `docs.json`. See the [settings documentation](/organize/settings-api) for details. When using this configuration, you must configure CORS on your server since requests come directly from users' browsers rather than through your proxy.
+
+ A CORS error occurs when your browser blocks a cross-origin request because the response is missing the required headers. You can identify a CORS error in your browser's developer console: look for messages like `Access-Control-Allow-Origin` missing or `blocked by CORS policy`.
+
+ CORS errors only affect requests that go directly from the user's browser to your API. By default, Mintlify proxies API Playground requests through `/_mintlify/api/request`, so most sites don't encounter CORS issues. You typically see CORS errors when:
+
+ - You've set `api.playground.proxy` to `false` in your `docs.json`, so requests bypass the Mintlify proxy.
+ - You've configured a custom `api.playground.proxy` URL that points directly to your backend.
+
+ To fix CORS errors, configure your API server to return the following response headers for requests from your docs site's origin:
+
+ - `Access-Control-Allow-Origin`: Your docs site's origin (for example, `https://docs.your-site.com`) or `*` for public APIs.
+ - `Access-Control-Allow-Methods`: The HTTP methods your API supports (for example, `GET, POST, PUT, DELETE, OPTIONS`).
+ - `Access-Control-Allow-Headers`: The headers your requests send (for example, `Content-Type, Authorization`).
+
+ Your server must also handle `OPTIONS` preflight requests. If you can't modify your API server, remove the `api.playground.proxy` setting so requests route through the Mintlify proxy again.
+
If you are using an OpenAPI navigation configuration, but the pages aren't generating, check these common issues:
diff --git a/editor/drafts.mdx b/editor/drafts.mdx
index 4139371aa3..5ae12eb805 100644
--- a/editor/drafts.mdx
+++ b/editor/drafts.mdx
@@ -67,6 +67,16 @@ When your draft is ready, open the publish menu to review your changes and publi
+## Preview a draft
+
+Because each draft has its own branch, it also has a [preview deployment](/editor/branching-and-publishing#preview-your-changes) that reflects the current state of the draft. Share the preview URL with reviewers to show unpublished changes before you publish.
+
+1. Open the draft you want to preview.
+2. Click **Publish** in the editor toolbar to open the publish menu.
+3. Copy the preview URL and send it to your reviewers.
+
+The preview updates automatically each time the editor saves your changes. Preview URLs are publicly accessible by default. To restrict access to members of your Mintlify organization, enable preview authentication in the [Add-ons](https://app.mintlify.com/products/addons) page of your dashboard.
+
## Rename a draft
1. Click the deployment selector in the editor toolbar.
diff --git a/es/ai/skillmd.mdx b/es/ai/skillmd.mdx
index f5b06ce21c..084d0a1485 100644
--- a/es/ai/skillmd.mdx
+++ b/es/ai/skillmd.mdx
@@ -168,6 +168,19 @@ Las skills restringidas por grupos:
Las skills sin el campo `groups` permanecen visibles para todos.
+
+ ### Validar un archivo de skill personalizado
+
+
+Antes de desplegar, verifica que tus archivos de skill personalizados sean válidos:
+
+- **Comprueba el frontmatter.** Cada archivo de skill personalizado debe comenzar con frontmatter YAML que incluya al menos un `name` y una `description`. Consulta [Campos de frontmatter](#frontmatter-fields) para ver la lista completa de campos admitidos.
+- **Previsualiza en local.** Ejecuta [`mint dev`](/es/organize/settings) para servir tu sitio localmente y abre `http://localhost:3000/skill.md` para comprobar que se carga tu archivo personalizado en lugar del generado.
+- **Verifica después de desplegar.** Cuando se despliegue tu sitio, añade `/skill.md` a la URL de tu sitio para ver el archivo de skill servido. Si tienes varias skills, obtén `/.well-known/agent-skills/index.json` para confirmar que cada skill personalizada aparece en el manifiesto de descubrimiento.
+- **Valida contra la especificación.** Compara tu archivo con la [especificación de agentskills.io](https://agentskills.io/specification) para confirmar que las secciones obligatorias están presentes y con el formato correcto.
+
+Los cambios en los archivos de skill personalizados se publican con tu siguiente despliegue. Como las skills generadas pueden tardar hasta 24 horas en actualizarse, las skills personalizadas son la forma más rápida de controlar lo que ven los agentes.
+
## Endpoints de descubrimiento de skills
diff --git a/es/api-playground/troubleshooting.mdx b/es/api-playground/troubleshooting.mdx
index 390335479a..cf456b63e9 100644
--- a/es/api-playground/troubleshooting.mdx
+++ b/es/api-playground/troubleshooting.mdx
@@ -77,6 +77,23 @@ Si sus páginas de la API no se muestran correctamente, revise estos problemas d
Como alternativa, si tu proxy inverso impide aceptar solicitudes `POST`, puedes configurar Mintlify para enviar solicitudes directamente a tu backend con el ajuste `api.playground.proxy` en el `docs.json`, como se describe en la [documentación de configuración](/es/organize/settings-api). Al usar esta configuración, deberás configurar CORS en tu servidor, ya que las solicitudes llegarán directamente desde los navegadores de los usuarios en lugar de pasar por tu proxy.
+
+ Un error de CORS se produce cuando tu navegador bloquea una solicitud entre orígenes porque a la respuesta le faltan los encabezados requeridos. Puedes identificar un error de CORS en la consola de desarrollador de tu navegador: busca mensajes como que falta `Access-Control-Allow-Origin` o `blocked by CORS policy`.
+
+ Los errores de CORS solo afectan a las solicitudes que van directamente desde el navegador del usuario a tu API. De forma predeterminada, Mintlify redirige las solicitudes del área de pruebas de la API a través de `/_mintlify/api/request`, por lo que la mayoría de los sitios no se encuentran con problemas de CORS. Normalmente ves errores de CORS cuando:
+
+ - Has establecido `api.playground.proxy` en `false` en tu `docs.json`, por lo que las solicitudes omiten el proxy de Mintlify.
+ - Has configurado una URL personalizada en `api.playground.proxy` que apunta directamente a tu backend.
+
+ Para corregir los errores de CORS, configura tu servidor de API para que devuelva los siguientes encabezados de respuesta en las solicitudes provenientes del origen de tu sitio de documentación:
+
+ - `Access-Control-Allow-Origin`: El origen de tu sitio de documentación (por ejemplo, `https://docs.your-site.com`) o `*` para APIs públicas.
+ - `Access-Control-Allow-Methods`: Los métodos HTTP que admite tu API (por ejemplo, `GET, POST, PUT, DELETE, OPTIONS`).
+ - `Access-Control-Allow-Headers`: Los encabezados que envían tus solicitudes (por ejemplo, `Content-Type, Authorization`).
+
+ Tu servidor también debe manejar las solicitudes de preflight `OPTIONS`. Si no puedes modificar tu servidor de API, elimina el ajuste `api.playground.proxy` para que las solicitudes vuelvan a enrutarse a través del proxy de Mintlify.
+
+
Si usas una configuración de navigation de OpenAPI, pero las páginas no se generan, revisa estos problemas comunes:
diff --git a/es/editor/drafts.mdx b/es/editor/drafts.mdx
index 9b74c57841..5c7952481b 100644
--- a/es/editor/drafts.mdx
+++ b/es/editor/drafts.mdx
@@ -75,6 +75,18 @@ Cuando tu borrador esté listo, abre el menú de publicación para revisar tus c
+
+ ## Previsualizar un borrador
+
+
+Como cada borrador tiene su propia branch, también tiene un [despliegue de previsualización](/es/editor/branching-and-publishing#preview-your-changes) que refleja el estado actual del borrador. Comparte la URL de previsualización con los revisores para mostrar los cambios sin publicar antes de publicarlos.
+
+1. Abre el borrador que quieres previsualizar.
+2. Haz clic en **Publish** en la barra de herramientas del editor para abrir el menú de publicación.
+3. Copia la URL de previsualización y envíala a tus revisores.
+
+La previsualización se actualiza automáticamente cada vez que el editor guarda tus cambios. Las URLs de previsualización son accesibles públicamente de forma predeterminada. Para restringir el acceso a los miembros de tu organización de Mintlify, activa la autenticación de previsualización en la página [Add-ons](https://app.mintlify.com/products/addons) de tu panel.
+
## Renombrar un borrador
diff --git a/es/integrations/analytics/overview.mdx b/es/integrations/analytics/overview.mdx
index b9eace0620..6cef517df2 100644
--- a/es/integrations/analytics/overview.mdx
+++ b/es/integrations/analytics/overview.mdx
@@ -540,6 +540,23 @@ Configura las credenciales de tu proveedor de Analytics en el objeto `integratio
}
```
+
+ ## Verifica tu configuración
+
+
+Después de desplegar el `docs.json` actualizado, comprueba que los eventos están llegando a tu proveedor de Analytics:
+
+1. **Despliega tus cambios.** Los eventos de Analytics solo comienzan a fluir después de que los cambios en tu `docs.json` se despliegan en tu sitio en producción. Las sesiones locales de `mint dev` no envían eventos.
+2. **Activa un evento.** Visita tu sitio en producción e interactúa con él. Consulta una página, realiza una búsqueda o envía una solicitud en el área de pruebas de la API para generar uno de los [eventos rastreados](#tracked-events).
+3. **Consulta la vista en tiempo real de tu proveedor.** La mayoría de las plataformas muestran los eventos entrantes en menos de un minuto:
+ - Google Analytics 4: **Reports → Realtime**.
+ - PostHog: **Activity → Live events**.
+ - Mixpanel: **Events → Live view**.
+ - Amplitude: **Data → Live event stream**.
+4. **Desactiva los bloqueadores de anuncios.** Extensiones del navegador como uBlock Origin y Privacy Badger bloquean muchos scripts de Analytics de forma predeterminada. Prueba en una ventana de incógnito con las extensiones desactivadas si los eventos no aparecen.
+
+Si los eventos siguen sin llegar, verifica de nuevo que estás usando el tipo de clave correcto para cada proveedor (consulta la nota en [Configuración](#setup)) y que los cambios en tu `docs.json` se han desplegado correctamente.
+
## Eventos rastreados
diff --git a/es/migration-services/go-live-checklist.mdx b/es/migration-services/go-live-checklist.mdx
new file mode 100644
index 0000000000..04f09f83d3
--- /dev/null
+++ b/es/migration-services/go-live-checklist.mdx
@@ -0,0 +1,55 @@
+---
+title: "Lista de verificación para la puesta en producción"
+description: "Verifica que tu sitio de Mintlify está listo antes de ponerlo en producción."
+noindex: true
+---
+
+Esta es una lista completa de configuraciones que debes establecer y ajustes que debes validar antes de la puesta en producción. Algunos pasos pueden no aplicarse a tu despliegue concreto y puedes omitirlos.
+
+## Configuración principal
+
+- **Conecta tu repositorio de documentación a Mintlify.** Instala la [app de GitHub](/es/deploy/github) o conecta tu [repositorio de GitLab](/es/deploy/gitlab).
+ - Si ya has instalado la app de GitHub, desinstálala y vuelve a instalarla. Para verificar este paso, realiza un cambio en tu documentación localmente, envíalo a GitHub y comprueba que tu sitio se vuelve a desplegar.
+ - Si almacenas tu documentación en más de un repositorio, configura una [estructura multi-repositorio](/es/deploy/multi-repo) para compilar tu sitio a partir de varios repositorios. Si todo tu contenido está en un único repositorio, omite este paso.
+- **Invita a los miembros del equipo.** Invita a cualquier persona que necesite acceso desde la página [Members](https://app.mintlify.com/settings/organization/members) de tu panel. Consulta [Roles](/es/dashboard/roles) para obtener más información.
+
+## Seguridad
+
+- Revisa quién puede acceder a tu panel.
+ - Configura el [SSO del panel](/es/dashboard/sso) para que tu equipo acceda al panel y al editor.
+ - Configura las [políticas de acceso al panel](/es/dashboard/network-access).
+ - Configura el [aprovisionamiento SCIM](/es/dashboard/scim).
+- Revisa el acceso a tu sitio de Mintlify.
+ - Si restringes tu sitio a determinados usuarios, configura la [autenticación](/es/deploy/authentication-setup).
+ - Revisa qué grupos tienen acceso a las páginas y qué páginas son públicas.
+
+## Validación del contenido
+
+- **Verifica tu arquitectura de la información.** ¿Es la estructura de navegación correcta? ¿Faltan secciones? Consulta los [tipos de contenido](/es/guides/content-types) como referencia.
+- Si es necesario, configura [redirecciones](/es/create/redirects).
+
+## Funciones del panel
+
+- **Activa y configura el asistente.** Consulta [Configurar el asistente](/es/assistant/configure) y [Añadir skills al asistente](/es/assistant/skills).
+- **Habilita los complementos.** Ve a la página [Add-ons](https://app.mintlify.com/settings/deployment/addons) de tu panel. Habilita los complementos relevantes, como los comentarios del agente, las [comprobaciones de CI](/es/deploy/ci), los temas relacionados y más.
+- **Configura el agente de Slack.** Esto te permite hacer cambios en tu contenido directamente desde Slack. Consulta [Añadir el agente a Slack](/es/agent/slack#add-the-agent-to-slack).
+- **Configura las automatizaciones.** Consulta [cómo habilitar una automatización](/es/automations/manage#enable-an-automation).
+- **Instala los plugins de Analytics relevantes.** Consulta la [lista de integraciones de Analytics](/es/integrations/analytics/overview).
+
+## Puesta en producción
+
+- **Configura tu dominio personalizado.** Consulta la [guía de dominio personalizado](/es/customize/custom-domain).
+
+
+ ## Verificación posterior al lanzamiento
+
+
+Después de que se propaguen los cambios de DNS y tu dominio personalizado esté activo, comprueba de forma puntual que todo funciona de principio a fin:
+
+- **Carga las páginas clave.** Visita tu página de inicio y varias páginas de alto tráfico en el dominio personalizado para confirmar que se muestran correctamente con SSL.
+- **Prueba la navegación y la búsqueda.** Haz clic en los elementos de navegación de nivel superior y realiza algunas búsquedas para confirmar que los resultados devuelven las páginas esperadas.
+- **Verifica las redirecciones.** Carga una URL de tu sitio de documentación anterior (o cualquier [redirección](/es/create/redirects) que hayas configurado) y confirma que llega a la página nueva correcta.
+- **Confirma el acceso autenticado.** Si tu sitio usa [autenticación](/es/deploy/authentication-setup), inicia sesión como usuario de prueba y verifica que puedes acceder a las páginas que tu grupo de usuarios tiene permitido ver.
+- **Revisa Analytics.** Abre la vista en tiempo real de tu proveedor de Analytics y confirma que los eventos están fluyendo desde el dominio en producción. Consulta [Verifica tu configuración](/es/integrations/analytics/overview#verify-your-setup).
+- **Ejecuta una comprobación de enlaces rotos.** Desde el directorio de tu proyecto, ejecuta `mint broken-links` para detectar cualquier enlace interno que siga apuntando al dominio antiguo o a páginas eliminadas.
+- **Prueba el área de pruebas de la API.** Si tu documentación incluye una referencia de API, envía una solicitud desde el área de pruebas y confirma que llega a tu backend sin errores de CORS.
diff --git a/fr/ai/skillmd.mdx b/fr/ai/skillmd.mdx
index eabfd8c54a..feaea02904 100644
--- a/fr/ai/skillmd.mdx
+++ b/fr/ai/skillmd.mdx
@@ -168,6 +168,19 @@ Les skills restreints par groupes :
Les skills sans champ `groups` restent visibles pour tous.
+
+ ### Valider un fichier de skill personnalisé
+
+
+Avant de déployer, vérifiez que vos fichiers de skill personnalisés sont valides :
+
+- **Vérifiez le frontmatter.** Chaque fichier de skill personnalisé doit commencer par un frontmatter YAML incluant au minimum un `name` et une `description`. Consultez les [champs de frontmatter](#frontmatter-fields) pour la liste complète des champs pris en charge.
+- **Prévisualisez localement.** Exécutez [`mint dev`](/fr/organize/settings) pour servir votre site en local, puis ouvrez `http://localhost:3000/skill.md` pour vérifier que votre fichier personnalisé se charge à la place du fichier généré.
+- **Vérifiez après le déploiement.** Une fois votre site déployé, ajoutez `/skill.md` à l'URL de votre site pour afficher le fichier de skill servi. Pour plusieurs skills, récupérez `/.well-known/agent-skills/index.json` afin de confirmer que chaque skill personnalisé apparaît dans le manifeste de découverte.
+- **Validez par rapport à la spécification.** Comparez votre fichier à la [spécification agentskills.io](https://agentskills.io/specification) pour confirmer que les sections requises sont présentes et correctement formatées.
+
+Les modifications apportées aux fichiers de skill personnalisés sont publiées lors de votre prochain déploiement. Les skills générés pouvant mettre jusqu'à 24 heures à se mettre à jour, les skills personnalisés constituent le moyen le plus rapide de contrôler ce que les agents voient.
+
## Endpoints de découverte des skills
diff --git a/fr/api-playground/troubleshooting.mdx b/fr/api-playground/troubleshooting.mdx
index 1c63767ef2..4f4264db18 100644
--- a/fr/api-playground/troubleshooting.mdx
+++ b/fr/api-playground/troubleshooting.mdx
@@ -72,6 +72,23 @@ Si vos pages API ne s’affichent pas correctement, consultez ces problèmes de
Sinon, si votre reverse proxy empêche l’acceptation des requêtes `POST`, vous pouvez configurer Mintlify pour envoyer les requêtes directement à votre backend avec le paramètre `api.playground.proxy` dans le `docs.json`, comme décrit dans la [documentation des paramètres](/fr/organize/settings-api). Avec cette configuration, vous devez configurer CORS sur votre serveur, car les requêtes proviennent directement des navigateurs des utilisateurs plutôt que de passer par votre proxy.
+
+ Une erreur CORS survient lorsque votre navigateur bloque une requête cross-origin parce que la réponse ne contient pas les en-têtes requis. Vous pouvez identifier une erreur CORS dans la console développeur de votre navigateur : recherchez des messages tels que `Access-Control-Allow-Origin` manquant ou `blocked by CORS policy`.
+
+ Les erreurs CORS n’affectent que les requêtes qui vont directement du navigateur de l’utilisateur à votre API. Par défaut, Mintlify fait transiter les requêtes du bac à sable d’API par `/_mintlify/api/request`, si bien que la plupart des sites ne rencontrent pas de problèmes CORS. Vous rencontrez généralement des erreurs CORS lorsque :
+
+ - Vous avez défini `api.playground.proxy` sur `false` dans votre `docs.json`, ce qui contourne le proxy Mintlify.
+ - Vous avez configuré une URL `api.playground.proxy` personnalisée qui pointe directement vers votre backend.
+
+ Pour corriger les erreurs CORS, configurez votre serveur API afin qu’il renvoie les en-têtes de réponse suivants pour les requêtes provenant de l’origine de votre site de documentation :
+
+ - `Access-Control-Allow-Origin` : l’origine de votre site de documentation (par exemple, `https://docs.your-site.com`) ou `*` pour les API publiques.
+ - `Access-Control-Allow-Methods` : les méthodes HTTP prises en charge par votre API (par exemple, `GET, POST, PUT, DELETE, OPTIONS`).
+ - `Access-Control-Allow-Headers` : les en-têtes envoyés par vos requêtes (par exemple, `Content-Type, Authorization`).
+
+ Votre serveur doit également gérer les requêtes préliminaires `OPTIONS`. Si vous ne pouvez pas modifier votre serveur API, supprimez le paramètre `api.playground.proxy` pour que les requêtes soient à nouveau acheminées via le proxy Mintlify.
+
+
Si vous utilisez une configuration de navigation OpenAPI, mais que les pages ne sont pas générées, vérifiez ces problèmes courants :
diff --git a/fr/editor/drafts.mdx b/fr/editor/drafts.mdx
index 5d7249068d..2a1da379bf 100644
--- a/fr/editor/drafts.mdx
+++ b/fr/editor/drafts.mdx
@@ -75,6 +75,18 @@ Lorsque votre brouillon est prêt, ouvrez le menu de publication pour passer en
+
+ ## Prévisualiser un brouillon
+
+
+Chaque brouillon disposant de sa propre branche, il dispose également d'un [déploiement de prévisualisation](/fr/editor/branching-and-publishing#preview-your-changes) qui reflète l'état actuel du brouillon. Partagez l'URL de prévisualisation avec les relecteurs pour leur montrer les modifications non publiées avant la publication.
+
+1. Ouvrez le brouillon que vous souhaitez prévisualiser.
+2. Cliquez sur **Publish** dans la barre d'outils de l'éditeur pour ouvrir le menu de publication.
+3. Copiez l'URL de prévisualisation et envoyez-la à vos relecteurs.
+
+La prévisualisation se met à jour automatiquement à chaque fois que l'éditeur enregistre vos modifications. Les URL de prévisualisation sont accessibles publiquement par défaut. Pour restreindre l'accès aux membres de votre organisation Mintlify, activez l'authentification de prévisualisation sur la page [Add-ons](https://app.mintlify.com/products/addons) de votre tableau de bord.
+
## Renommer un brouillon
diff --git a/fr/integrations/analytics/overview.mdx b/fr/integrations/analytics/overview.mdx
index 87a436ce91..fec38aa45c 100644
--- a/fr/integrations/analytics/overview.mdx
+++ b/fr/integrations/analytics/overview.mdx
@@ -540,6 +540,23 @@ Ajoutez les identifiants de votre fournisseur d’Analytics à l’objet `integr
}
```
+
+ ## Vérifier votre configuration
+
+
+Après avoir déployé votre `docs.json` mis à jour, vérifiez que les événements arrivent bien à votre fournisseur d’Analytics :
+
+1. **Déployez vos modifications.** Les événements d’Analytics ne commencent à circuler qu’une fois les modifications de votre `docs.json` déployées sur votre site en production. Les sessions locales `mint dev` n’envoient pas d’événements.
+2. **Déclenchez un événement.** Rendez-vous sur votre site en production et interagissez avec lui. Consultez une page, exécutez une recherche ou effectuez une requête depuis le bac à sable d’API pour générer l’un des [événements suivis](#tracked-events).
+3. **Consultez la vue en temps réel de votre fournisseur.** La plupart des plateformes affichent les événements entrants en moins d’une minute :
+ - Google Analytics 4 : **Reports → Realtime**.
+ - PostHog : **Activity → Live events**.
+ - Mixpanel : **Events → Live view**.
+ - Amplitude : **Data → Live event stream**.
+4. **Désactivez les bloqueurs de publicités.** Les extensions de navigateur comme uBlock Origin et Privacy Badger bloquent par défaut de nombreux scripts d’Analytics. Testez dans une fenêtre de navigation privée avec les extensions désactivées si les événements n’apparaissent pas.
+
+Si les événements ne parviennent toujours pas, vérifiez à nouveau que vous utilisez le bon type de clé pour chaque fournisseur (voir la note dans [Configuration](#setup)) et que les modifications de votre `docs.json` ont bien été déployées.
+
## Événements suivis
diff --git a/fr/migration-services/go-live-checklist.mdx b/fr/migration-services/go-live-checklist.mdx
new file mode 100644
index 0000000000..bed7898902
--- /dev/null
+++ b/fr/migration-services/go-live-checklist.mdx
@@ -0,0 +1,55 @@
+---
+title: "Checklist de mise en production"
+description: "Vérifiez que votre site Mintlify est prêt avant la mise en production."
+noindex: true
+---
+
+Voici une liste complète des configurations à mettre en place et des paramètres à valider avant la mise en production. Certaines étapes peuvent ne pas s'appliquer à votre déploiement spécifique et vous pouvez les ignorer.
+
+## Configuration de base
+
+- **Connectez votre dépôt de docs à Mintlify.** Installez la [GitHub app](/fr/deploy/github) ou connectez votre [dépôt GitLab](/fr/deploy/gitlab).
+ - Si vous avez déjà installé la GitHub app, désinstallez-la et réinstallez-la. Pour vérifier cette étape, effectuez une modification locale de votre documentation, poussez-la sur GitHub et vérifiez que votre site se redéploie.
+ - Si vous stockez votre documentation dans plusieurs dépôts, configurez une [structure multi-dépôts](/fr/deploy/multi-repo) pour construire votre site à partir de plusieurs dépôts. Si tout votre contenu se trouve dans un seul dépôt, ignorez cette étape.
+- **Invitez les membres de l'équipe.** Invitez toute personne ayant besoin d'un accès depuis la page [Members](https://app.mintlify.com/settings/organization/members) de votre dashboard. Consultez [Rôles](/fr/dashboard/roles) pour plus d'informations.
+
+## Sécurité
+
+- Vérifiez qui peut accéder à votre dashboard.
+ - Configurez le [SSO du dashboard](/fr/dashboard/sso) pour que votre équipe accède au dashboard et à l'éditeur.
+ - Configurez les [politiques d'accès au dashboard](/fr/dashboard/network-access).
+ - Configurez le [provisioning SCIM](/fr/dashboard/scim).
+- Vérifiez l'accès à votre site Mintlify.
+ - Si vous limitez l'accès à votre site à certains utilisateurs, configurez l'[authentification](/fr/deploy/authentication-setup).
+ - Vérifiez quels groupes ont accès à quelles pages et quelles pages sont publiques.
+
+## Validation du contenu
+
+- **Vérifiez votre architecture de l'information.** La structure de navigation est-elle appropriée ? Manque-t-il des sections ? Consultez les [types de contenu](/fr/guides/content-types) pour référence.
+- Si nécessaire, configurez des [redirections](/fr/create/redirects).
+
+## Fonctionnalités du dashboard
+
+- **Activez et configurez l'assistant.** Consultez [Configurer l'assistant](/fr/assistant/configure) et [Ajouter des skills à l'assistant](/fr/assistant/skills).
+- **Activez les add-ons.** Rendez-vous sur la page [Add-ons](https://app.mintlify.com/settings/deployment/addons) de votre dashboard. Activez les add-ons pertinents comme le retour de l'agent, les [vérifications CI](/fr/deploy/ci), les sujets connexes, et plus encore.
+- **Configurez l'agent Slack.** Cela vous permet de modifier votre contenu directement depuis Slack. Consultez [Ajouter l'agent à Slack](/fr/agent/slack#add-the-agent-to-slack).
+- **Configurez les automatisations.** Consultez [comment activer une automatisation](/fr/automations/manage#enable-an-automation).
+- **Installez les plugins d'analytique pertinents.** Consultez la [liste des intégrations d'analytique](/fr/integrations/analytics/overview).
+
+## Mise en production
+
+- **Définissez votre domaine personnalisé.** Consultez le [guide du domaine personnalisé](/fr/customize/custom-domain).
+
+
+ ## Vérification post-lancement
+
+
+Une fois la propagation DNS terminée et votre domaine personnalisé en ligne, effectuez des vérifications ponctuelles pour confirmer que tout fonctionne de bout en bout :
+
+- **Chargez les pages clés.** Visitez votre page d'accueil et quelques pages à fort trafic sur le domaine personnalisé pour confirmer qu'elles s'affichent correctement en SSL.
+- **Testez la navigation et la recherche.** Cliquez sur les éléments de navigation de premier niveau et effectuez quelques recherches pour confirmer que les résultats renvoient les pages attendues.
+- **Vérifiez les redirections.** Chargez une URL de votre ancien site de docs (ou toute [redirection](/fr/create/redirects) que vous avez configurée) et confirmez qu'elle atteint la bonne nouvelle page.
+- **Confirmez l'accès authentifié.** Si votre site utilise l'[authentification](/fr/deploy/authentication-setup), connectez-vous en tant qu'utilisateur de test et vérifiez que vous pouvez accéder aux pages que votre groupe d'utilisateurs est autorisé à consulter.
+- **Vérifiez l'analytique.** Ouvrez la vue en temps réel de votre fournisseur d'analytique et confirmez que les événements arrivent bien depuis le domaine en production. Consultez [Vérifier votre configuration](/fr/integrations/analytics/overview#verify-your-setup).
+- **Lancez une vérification des liens cassés.** Depuis le répertoire de votre projet, exécutez `mint broken-links` pour détecter tout lien interne qui pointerait encore vers l'ancien domaine ou vers des pages supprimées.
+- **Testez l'API playground.** Si votre documentation inclut une référence API, envoyez une requête depuis le playground et confirmez qu'elle atteint votre backend sans erreur CORS.
diff --git a/integrations/analytics/overview.mdx b/integrations/analytics/overview.mdx
index 6770034df0..169c4b9d70 100644
--- a/integrations/analytics/overview.mdx
+++ b/integrations/analytics/overview.mdx
@@ -534,6 +534,21 @@ Analytics integrations only require public API keys, which are accessible to any
}
```
+## Verify your setup
+
+After you deploy your updated `docs.json`, verify that events are reaching your analytics provider:
+
+1. **Deploy your changes.** Analytics events only start flowing after your `docs.json` changes are deployed to your live site. Local `mint dev` sessions do not send events.
+2. **Trigger an event.** Visit your live site and interact with it. View a page, run a search, or make an API playground request to generate one of the [tracked events](#tracked-events).
+3. **Check your provider's realtime view.** Most platforms show incoming events within a minute:
+ - Google Analytics 4: **Reports → Realtime**.
+ - PostHog: **Activity → Live events**.
+ - Mixpanel: **Events → Live view**.
+ - Amplitude: **Data → Live event stream**.
+4. **Disable ad blockers.** Browser extensions like uBlock Origin and Privacy Badger block many analytics scripts by default. Test in an incognito window with extensions disabled if events don't appear.
+
+If events still aren't arriving, double-check that you're using the correct key type for each provider (see the note in [Setup](#setup)) and that your `docs.json` changes have deployed successfully.
+
## Tracked events
All tracked events use the `docs.` prefix.
diff --git a/migration-services/go-live-checklist.mdx b/migration-services/go-live-checklist.mdx
index caa18459ca..3dcd945a15 100644
--- a/migration-services/go-live-checklist.mdx
+++ b/migration-services/go-live-checklist.mdx
@@ -39,3 +39,15 @@ This is a comprehensive list of configurations to set up and settings to validat
## Go live
- **Set your custom domain.** See the [custom domain guide](/customize/custom-domain).
+
+## Post-launch verification
+
+After DNS changes propagate and your custom domain is live, spot-check that everything works end to end:
+
+- **Load key pages.** Visit your home page and a handful of high-traffic pages on the custom domain to confirm they render correctly with SSL.
+- **Test navigation and search.** Click through top-level navigation items and run a few searches to confirm results return the expected pages.
+- **Verify redirects.** Load a URL from your previous docs site (or any [redirect](/create/redirects) you configured) and confirm it lands on the correct new page.
+- **Confirm authenticated access.** If your site uses [authentication](/deploy/authentication-setup), sign in as a test user and verify you can access the pages your user group is allowed to see.
+- **Check analytics.** Open your analytics provider's realtime view and confirm events are flowing from the live domain. See [Verify your setup](/integrations/analytics/overview#verify-your-setup).
+- **Run a broken-link check.** From your project directory, run `mint broken-links` to catch any internal links that still point to the old domain or removed pages.
+- **Test the API playground.** If your docs include an API reference, send a request from the playground and confirm it reaches your backend without CORS errors.
diff --git a/zh/ai/skillmd.mdx b/zh/ai/skillmd.mdx
index 63eb986f3a..e9c31e92d8 100644
--- a/zh/ai/skillmd.mdx
+++ b/zh/ai/skillmd.mdx
@@ -168,6 +168,19 @@ groups: ["admin"]
未设置 `groups` 字段的技能对所有人可见。
+
+ ### 验证自定义 skill 文件
+
+
+在部署之前，请确认你的自定义 skill 文件是有效的：
+
+- **检查 frontmatter。** 每个自定义 skill 文件都必须以 YAML frontmatter 开头，并至少包含 `name` 和 `description`。请参阅 [Frontmatter 字段](#frontmatter-fields) 获取受支持字段的完整列表。
+- **在本地预览。** 运行 [`mint dev`](/zh/organize/settings) 在本地启动你的站点，然后打开 `http://localhost:3000/skill.md` 检查加载的是你的自定义文件，而不是自动生成的文件。
+- **部署后验证。** 站点部署完成后，在站点 URL 后追加 `/skill.md` 查看已提供的 skill 文件。对于多个 skill，请获取 `/.well-known/agent-skills/index.json` 以确认每个自定义 skill 都出现在发现清单中。
+- **对照规范进行验证。** 将你的文件与 [agentskills.io 规范](https://agentskills.io/specification) 进行比对，确认必需的部分都已存在且格式正确。
+
+对自定义 skill 文件的更改会随下一次部署一起发布。由于生成的 skill 最长可能需要 24 小时才会更新，自定义 skill 是控制代理所见内容的最快方式。
+
## Skills 发现端点
diff --git a/zh/api-playground/troubleshooting.mdx b/zh/api-playground/troubleshooting.mdx
index 8b78b29fd9..a96a2b7129 100644
--- a/zh/api-playground/troubleshooting.mdx
+++ b/zh/api-playground/troubleshooting.mdx
@@ -70,6 +70,23 @@ boost: 3
或者，如果你的反向代理禁止接受 `POST` 请求，你可以在 `docs.json` 中通过 `api.playground.proxy` 设置，让 Mintlify 直接将请求发送到你的后端，具体参见[设置文档](/zh/organize/settings-api)。使用此配置时，你必须在服务器上配置 CORS，因为请求是直接来自用户的浏览器，而不是通过你的代理。
+
+ 当你的浏览器由于响应缺少必需的 header 而阻止跨源请求时，就会发生 CORS 错误。你可以在浏览器的开发者控制台中识别 CORS 错误：查找诸如 `Access-Control-Allow-Origin` 缺失或 `blocked by CORS policy` 之类的消息。
+
+ CORS 错误仅影响直接从用户浏览器发往你的 API 的请求。默认情况下，Mintlify 会通过 `/_mintlify/api/request` 代理 API 操作台的请求，因此大多数站点不会遇到 CORS 问题。你通常会在以下情况下看到 CORS 错误：
+
+ - 你在 `docs.json` 中将 `api.playground.proxy` 设置为 `false`，因此请求绕过了 Mintlify 代理。
+ - 你配置了一个直接指向你后端的自定义 `api.playground.proxy` URL。
+
+ 要解决 CORS 错误，请将你的 API 服务器配置为针对来自文档站点源的请求返回以下响应 header：
+
+ - `Access-Control-Allow-Origin`：你的文档站点源（例如 `https://docs.your-site.com`），或对公共 API 使用 `*`。
+ - `Access-Control-Allow-Methods`：你的 API 所支持的 HTTP 方法（例如 `GET, POST, PUT, DELETE, OPTIONS`）。
+ - `Access-Control-Allow-Headers`：你的请求所发送的 header（例如 `Content-Type, Authorization`）。
+
+ 你的服务器还必须处理 `OPTIONS` 预检请求。如果你无法修改 API 服务器，请移除 `api.playground.proxy` 设置，让请求重新通过 Mintlify 代理路由。
+
+
如果你使用的是 OpenAPI 导航配置，但页面未生成，请检查以下常见问题：
diff --git a/zh/editor/drafts.mdx b/zh/editor/drafts.mdx
index 78843690ce..18744102e1 100644
--- a/zh/editor/drafts.mdx
+++ b/zh/editor/drafts.mdx
@@ -75,6 +75,18 @@ keywords: ["editor", "draft", "publish", "autosave"]
+
+ ## 预览草稿
+
+
+由于每个草稿都有自己的分支,因此它也有一个反映草稿当前状态的[预览部署](/zh/editor/branching-and-publishing#preview-your-changes)。将预览 URL 分享给审阅者,即可在发布之前展示尚未发布的更改。
+
+1. 打开你想要预览的草稿。
+2. 点击编辑器工具栏中的 **Publish** 以打开发布菜单。
+3. 复制预览 URL 并将其发送给审阅者。
+
+每次编辑器保存你的更改时,预览都会自动更新。预览 URL 默认是公开可访问的。若要将访问权限限制为你所在 Mintlify 组织的成员,请在仪表板的 [Add-ons](https://app.mintlify.com/products/addons) 页面启用预览身份验证。
+
## 重命名草稿
diff --git a/zh/integrations/analytics/overview.mdx b/zh/integrations/analytics/overview.mdx
index 697967d243..f4851cb835 100644
--- a/zh/integrations/analytics/overview.mdx
+++ b/zh/integrations/analytics/overview.mdx
@@ -540,6 +540,23 @@ fill="#7166F6"
}
```
+
+ ## 验证你的配置
+
+
+在部署更新后的 `docs.json` 后，请验证事件是否已到达你的 analytics 提供商：
+
+1. **部署你的更改。** 只有在 `docs.json` 的更改部署到线上站点后，analytics 事件才会开始上报。本地 `mint dev` 会话不会发送事件。
+2. **触发一个事件。** 访问你的线上站点并与其交互。查看页面、执行搜索或发起一次 API 操作台请求，以生成一个[跟踪事件](#tracked-events)。
+3. **检查你的提供商的实时视图。** 大多数平台会在一分钟内显示传入的事件：
+ - Google Analytics 4：**Reports → Realtime**。
+ - PostHog：**Activity → Live events**。
+ - Mixpanel：**Events → Live view**。
+ - Amplitude：**Data → Live event stream**。
+4. **禁用广告拦截器。** uBlock Origin 和 Privacy Badger 等浏览器扩展默认会屏蔽许多 analytics 脚本。如果事件未显示，请在禁用扩展的隐身窗口中进行测试。
+
+如果事件仍未到达，请再次确认你为每个提供商使用的是正确的 key 类型（参见[设置](#setup)中的说明），并且你的 `docs.json` 更改已成功部署。
+
## 跟踪事件
diff --git a/zh/migration-services/go-live-checklist.mdx b/zh/migration-services/go-live-checklist.mdx
new file mode 100644
index 0000000000..99adebec41
--- /dev/null
+++ b/zh/migration-services/go-live-checklist.mdx
@@ -0,0 +1,55 @@
+---
+title: "上线前检查清单"
+description: "在上线前，验证你的 Mintlify 站点是否已准备就绪。"
+noindex: true
+---
+
+这是一份在上线前需要完成的配置和需要验证的设置的完整清单。部分步骤可能不适用于你的具体部署，你可以跳过它们。
+
+## 核心设置
+
+- **将你的文档仓库连接到 Mintlify。** 安装 [GitHub app](/zh/deploy/github) 或连接你的 [GitLab 仓库](/zh/deploy/gitlab)。
+ - 如果你已经安装了 GitHub app，请卸载并重新安装。要验证此步骤，请在本地对你的文档做一次更改，推送到 GitHub，并检查你的站点是否会重新部署。
+ - 如果你的文档存放在多个仓库中，请配置[多仓库结构](/zh/deploy/multi-repo)，以便从多个仓库构建你的站点。如果你的所有内容都在同一个仓库中，可以跳过此步骤。
+- **邀请团队成员。** 从仪表板的 [Members](https://app.mintlify.com/settings/organization/members) 页面邀请任何需要访问权限的人。更多信息参见[角色](/zh/dashboard/roles)。
+
+## 安全
+
+- 审查谁可以访问你的仪表板。
+ - 为团队访问仪表板和编辑器设置[仪表板 SSO](/zh/dashboard/sso)。
+ - 设置[仪表板访问策略](/zh/dashboard/network-access)。
+ - 设置 [SCIM 预配](/zh/dashboard/scim)。
+- 审查你的 Mintlify 站点访问权限。
+ - 如果你将站点限制为特定用户访问，请设置[身份验证](/zh/deploy/authentication-setup)。
+ - 审查哪些用户组可以访问哪些页面，以及哪些页面是公开的。
+
+## 内容验证
+
+- **验证你的信息架构。** 这是合适的导航结构吗？是否缺少某些部分？可参考[内容类型](/zh/guides/content-types)。
+- 如有需要，设置[重定向](/zh/create/redirects)。
+
+## 仪表板功能
+
+- **开启并配置 assistant。** 参见[配置 assistant](/zh/assistant/configure) 和[添加 assistant skills](/zh/assistant/skills)。
+- **启用 Add-ons。** 前往仪表板中的 [Add-ons](https://app.mintlify.com/settings/deployment/addons) 页面。启用相关的 add-ons，例如 agent 反馈、[CI 检查](/zh/deploy/ci)、相关主题等。
+- **设置 Slack agent。** 这可以让你直接在 Slack 中修改你的内容。参见[将 agent 添加到 Slack](/zh/agent/slack#add-the-agent-to-slack)。
+- **设置自动化。** 参见[如何启用自动化](/zh/automations/manage#enable-an-automation)。
+- **安装相关的 analytics 插件。** 参见 [analytics 集成列表](/zh/integrations/analytics/overview)。
+
+## 上线
+
+- **设置你的自定义域名。** 参见[自定义域名指南](/zh/customize/custom-domain)。
+
+
+ ## 上线后验证
+
+
+在 DNS 更改传播完成、你的自定义域名上线后，请抽查确认所有环节都能正常端到端工作：
+
+- **加载关键页面。** 访问你的主页以及自定义域名上一些访问量较高的页面，确认它们能够正确渲染并启用了 SSL。
+- **测试导航和搜索。** 点击顶级导航项，并执行若干次搜索，确认结果返回的是预期的页面。
+- **验证重定向。** 加载一个来自你先前文档站点的 URL（或你配置的任何[重定向](/zh/create/redirects)），并确认它落到了正确的新页面。
+- **确认已认证的访问。** 如果你的站点使用了[身份验证](/zh/deploy/authentication-setup)，请以测试用户身份登录，并验证你能够访问该用户组被允许查看的页面。
+- **检查 analytics。** 打开你的 analytics 提供商的实时视图，确认事件正从线上域名流入。参见[验证你的配置](/zh/integrations/analytics/overview#verify-your-setup)。
+- **运行失效链接检查。** 在你的项目目录中运行 `mint broken-links`，以捕获任何仍指向旧域名或已移除页面的内部链接。
+- **测试 API 操作台。** 如果你的文档包含 API 参考，请从操作台发起一次请求，确认它能到达你的后端且没有 CORS 错误。