# Publicar y compartir

Publicar es el traspaso de tu agente a la plataforma mantenida: el panel deja de ser la salida de un agente y se convierte en algo con lo que tu equipo puede contar — una URL estable, gobernada por tus derechos de acceso, que sigue respondiendo cuando la sesión ha terminado.

## Draft y main son ramas de git reales[​](#draft-y-main-son-ramas-de-git-reales "Enlace directo al Draft y main son ramas de git reales")

Esto no es una metáfora. Cada panel es un **repositorio git**, guardado como un repo desnudo en almacenamiento de objetos. Tus ediciones — desde tu agente, desde el asistente integrado, desde el editor de código — son commits en una rama **draft** (borrador). Publicar fusiona ese borrador en **main**.

Tres consecuencias que vale la pena tener en cuenta:

* **No puedes escribir directamente en `main`.** Las escrituras en ella se rechazan; la única forma en que el contenido llega a la versión en vivo es una publicación.
* **Cada publicación crea una etiqueta de versión.** La etiqueta registra el estado en el que estaba `main` *antes* del merge — así que `v1` es lo que reemplazó tu primera publicación, `v2` es lo que reemplazó tu segunda publicación, y la versión actualmente en vivo es `main`, sin etiquetar hasta la próxima publicación.
* **Las publicaciones concurrentes se fusionan en lugar de sobrescribirse.** Si `main` se movió mientras tu borrador estaba abierto y los dos tocaron archivos diferentes, ambos conjuntos de cambios se aplican. Si tocaron el *mismo* archivo de forma incompatible, la publicación falla con `409 PUBLISH_MERGE_CONFLICT` y nombra las rutas en conflicto. No elige un ganador en silencio.

Puedes leer ese historial:

```
print(client.viz.list_tags(viz_id))

print(client.viz.get_commit_log(viz_id, "main", max_count=20))

print(client.viz.preview_publish(viz_id))   # diferencia entre draft y main
```

```
console.log(await client.viz.listTags(vizId));

console.log(await client.viz.getCommitLog(vizId, 'main', { maxCount: 20 }));

console.log(await client.viz.previewPublish(vizId));
```

## Publica un panel[​](#publica-un-panel "Enlace directo al Publica un panel")

Tu agente puede hacerlo directamente por [MCP](/es/guides/build-with-your-agent.md); en la aplicación es el botón **Publicar**; desde código es una llamada:

```
client.viz.publish(viz_id)
```

```
await client.viz.publish(vizId);
```

Publicar ejecuta primero una comprobación de salud sobre el último build del panel. Si el paquete está `FAILED` o desactualizado, la publicación se rechaza con un `409` en lugar de promover algo que no renderiza — pasa `force=true` para anular eso deliberadamente.

La publicación entonces fusiona, etiqueta, e inicia un build. **El estado solo pasa a `PUBLISHED` cuando ese build tiene éxito**; si falla, el panel cae en `ERROR` y `main` se restablece. Así que que `publish()` devuelva respuesta no es el mismo hecho que "el panel está en vivo" — lee `publishStatus` de vuelta antes de decirle a alguien que el enlace funciona. (Misma regla que [la actualización que devuelve `202`](/es/guides/keep-your-data-fresh.md#refresh-a-dataset-now): que la llamada se complete y que el trabajo se complete son dos cosas distintas.)

## Quién puede abrirlo — tres modos, no dos[​](#quién-puede-abrirlo--tres-modos-no-dos "Enlace directo al Quién puede abrirlo — tres modos, no dos")

Publicar decide *que* el panel está en vivo. Un campo separado, `viewMode`, decide *quién* puede abrirlo. Confundir estos dos es el error más común aquí.

| `viewMode`  | Quién puede abrirlo                                                                                                                                               |
| ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `public`    | Cualquiera con el enlace. Sin cuenta necesaria.                                                                                                                   |
| `protected` | Solo un visor para el que tu backend generó un token de incrustación — con filtros de fila por visor. Mira [Incrustación](/es/api/embedding-the-share-iframe.md). |
| `private`   | Nadie fuera de tu cuenta. Publicado, pero no alcanzable desde la superficie pública.                                                                              |

El enlace de un panel publicado tiene este aspecto:

```
https://cloud.vibedasher.com/v/<slug>
```

Esa URL solo sirve contenido cuando el panel está **ambos**: publicado **y** `public`. Un panel `protected` en la misma URL necesita un token añadido.

### Hacerlo público está protegido por separado, y un agente no puede hacerlo solo[​](#going-public-is-gated-separately-and-an-agent-cannot-do-it-alone "Enlace directo al Hacerlo público está protegido por separado, y un agente no puede hacerlo solo")

Hacer los datos de la empresa legibles para todo el mundo es lo único irreversible en todo este flujo, así que tiene su propia puerta en lugar de acompañar a `publish`. Dos interruptores, ambos en la cuenta, ambos comprobados en el servidor en cada ruta que pueda escribir `viewMode`:

* **`allowForPublicViz`** — un interruptor de emergencia a nivel de cuenta. Apágalo y nada en la cuenta puede hacerse público, por nadie, por ninguna ruta.
* **`apiKeysMayPublish`** — **es `false` por defecto.** Incluso cuando la compartición pública está permitida, un llamante que se autentica con una **clave de API** puede no ser quien pueda pasar un panel a público. Un admin tiene que activar esto, y solo puede hacerlo desde una sesión de navegador — `PUT /v1/account` rechaza establecerlo desde una clave de API, así que el interruptor no puede activarse a sí mismo.

Ese segundo punto es la clave. En cualquier otro sitio de esta plataforma una clave de API actúa como su usuario creador con el rol completo de ese usuario (mira [Quién puede ver qué](/es/guides/who-can-see-what.md)). Publicar en internet abierto es la excepción deliberada: tu agente puede construir el panel, publicarlo, y compartirlo dentro de tu cuenta, pero por defecto no puede ser lo que lo haga público. Un humano en un navegador tiene que haber dicho que sí una vez, al nivel de la cuenta.

## El código está congelado; los datos no[​](#el-código-está-congelado-los-datos-no "Enlace directo al El código está congelado; los datos no")

Esta es la propiedad que hace que un panel publicado valga la pena alojarlo en lugar de exportarlo.

**El código del panel se congela en una foto en el momento de publicar.** El paquete se construye una vez y se sirve desde almacenamiento. Tu borrador sigue evolucionando de forma independiente y no se filtra a la versión en vivo hasta que vuelvas a publicar.

**Los datos se leen en vivo en el momento de la visualización.** Cada gráfico en un panel publicado consulta el contenido actual de sus conjuntos de datos cuando alguien lo abre. Una actualización que llega a las 3 de la madrugada aparece en el panel publicado a las 9 de la mañana sin nada reconstruido y sin nadie pendiente. Esa es la razón entera por la que la mitad de los datos vive en la plataforma — mira [Mantén tus datos frescos](/es/guides/keep-your-data-fresh.md).

## Despublicar y volver a publicar[​](#despublicar-y-volver-a-publicar "Enlace directo al Despublicar y volver a publicar")

`DELETE /v1/viz/{id}/publish` retira el panel: el estado vuelve a `NOT_PUBLISHED` y el paquete en vivo se elimina. Tu borrador queda intacto.

* **El slug se conserva y sigue reservado**, así que volver a publicar reutiliza la misma URL.
* **Los enlaces antiguos fallan de forma inconsistente.** La página del visor responde `404`, la API pública responde `403`, y los endpoints de datos en caché responden `404`. Si estás manejando esto programáticamente, no ramifiques solo por el código de estado.
* **Renombrar el slug rompe permanentemente todos los enlaces existentes.** No hay redirección de un slug antiguo a uno nuevo. Elige el slug antes de difundir la URL.

## Incrústalo[​](#incrústalo "Enlace directo al Incrústalo")

Los paneles publicados se renderizan a través de un iframe incrustable que puedes colocar en cualquier aplicación, página de documentación, o sitio web — público, o protegido por visor con filtros a nivel de fila. Mira **[Incrustar un panel](/es/api/embedding-the-share-iframe.md)**.