# Responder HTML, XML, JSON, texto o archivos
Un programa web responde escribiendo en `@http_context<"response/...">`. Hay cuatro formas, según el miembro `response/output`:
| `output` | El cuerpo es | Úselo para |
|---|---|---|
| `standard` (predeterminado) | La salida declarativa del programa (el árbol XML/HTML) | Páginas HTML y documentos XML |
| `text` | La cadena de `response/text` | JSON, texto plano, HTML armado con plantillas, CSV |
| `binary` | El arreglo de bytes de `response/binary` | Archivos: PDF, imágenes, zip, Excel |
Siempre fije el tipo de contenido (`response/headers/content-type`). Vea la lista de tipos MIME comunes en [MDN](https://developer.mozilla.org/es/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types).
Todas las salidas de esta página son reales, obtenidas con Devkron 2.0 detrás de nginx (se omitieron los encabezados que el servidor agrega siempre: `Cache-Control`, `Date`, `Server`, `X-Powered-By`, `Content-Length`).
## HTML
La salida de un programa DKL es un árbol XML, así que producir HTML es escribirlo en el contexto declarativo. `#set "meta-xml-declaration"` sustituye la línea `` por la declaración de tipo de documento:
```dkl
#include "dkli.dkh"
#set "meta-xml-declaration" "\r\n"
html(lang="es")
{
head
{
title{$"Título de la página"}
}
body
{
h1{$"Encabezado"}
p{$"Párrafo de texto"}
}
}
```
```text
HTTP/1.1 200 OK
Content-Type: text/html;charset=utf-8
Título de la páginaEncabezado
Párrafo de texto
```
Para mezclar datos con HTML use un programa imperativo con bloques declarativos `##`, como en [Primer sitio web](/es/devkron/2.0/introduccion/primer-sitio.md), y para sitios con plantillas comunes use [website.dkl](/es/devkron/2.0/marcos/sitios/).
## XML
Igual que HTML, pero con otro tipo de contenido. Cambie al contexto imperativo solo para fijar el encabezado:
```dkl
#include "dkli.dkh"
xml
{
#!
@http_context<"response/headers/content-type">:"text/xml;charset=utf-8"
#$
cliente(nombre="Juan Pérez")
{
compras
{
compra(id="V001" fecha="2026-01-23" total="1992.5"){}
compra(id="V032" fecha="2026-02-03" total="4852"){}
}
}
}
```
```text
HTTP/1.1 200 OK
Content-Type: text/xml;charset=utf-8
```
Un documento siempre tiene un único nodo raíz (aquí, `xml`).
## JSON
Arme un registro, serialícelo con `to.json` (de `serialize.dkh`) y respóndalo como texto:
```dkl
#include "dkli.dkh"
#!
program "ejemplo-json"
{
#include "serialize.dkh"
new datos
{
@"nombre": "Juan"
@"apellido": "Pérez López"
}
@http_context<"response/headers/content-type">: "application/json;charset=utf-8"
@http_context<"response/output">: "text"
@http_context<"response/text">: to.json(datos)
}
```
```text
HTTP/1.1 200 OK
Content-Type: application/json;charset=utf-8
{"nombre":"Juan","apellido":"Pérez López"}
```
`to.json` escapa los caracteres no ASCII (`é`); cualquier cliente JSON los lee como `é`. Los valores lógicos `@true` y `@false` se serializan como `1` y `0`.
### El formato `{success, data}`
Es una convención muy usada en servicios JSON (la siguen, por ejemplo, las API de Induxsoft): responder siempre **HTTP 200** con uno de estos dos cuerpos, y el cliente decide por `success`:
```json
{ "success": true, "data": { } }
{ "success": false, "message": "Descripción del error" }
```
Con DKL queda así (`success` sale como `1` o `0`, que los clientes tratan como verdadero o falso):
```dkl
#include "dkli.dkh"
#!
program "formato-api"
{
#include "functions.dkh"
#include "serialize.dkh"
do errordet(@false) // mensajes de error sin código ni número de línea
new r { @"success": @true }
codeblock
{
id = @@(@http_context, "#request/get/id")
if id <= 0 { do rise_error(400, "Indique el parámetro id") }
new datos
{
@"id": id
@"nombre": "Producto " + str(id)
}
r<"data*">: datos
exception
{
r<"success">: @false
r<"message">: last_error()
}
}
@http_context<"response/headers/content-type">: "application/json;charset=utf-8"
@http_context<"response/output">: "text"
@http_context<"response/text">: to.json(r)
}
```
```text
GET /formato-api.dkl?id=7 → {"success":1,"data":{"id":7,"nombre":"Producto 7"}}
GET /formato-api.dkl → {"success":0,"message":"Indique el par\u00E1metro id"}
```
Un servicio completo con modelo, controlador y vista está en la guía [Servicio REST JSON](/es/devkron/2.0/guias/servicio-rest-json.md).
## Texto plano
```dkl
#include "dkli.dkh"
#!
program "ejemplo-texto"
{
@http_context<"response/headers/content-type">: "text/plain;charset=utf-8"
@http_context<"response/output">: "text"
@http_context<"response/text">: "Hola mundo (enviado como texto plano)"
}
```
```text
HTTP/1.1 200 OK
Content-Type: text/plain;charset=utf-8
Hola mundo (enviado como texto plano)
```
## Un archivo (binario)
Lea el archivo como bytes con `file.rbytes`, asígnelo a `response/binary` **con asterisco** (es un objeto) y ponga `output` en `binary`. `Content-Disposition` decide si el navegador lo descarga (`attachment`) o lo muestra (`inline`):
```dkl
#include "dkli.dkh"
#!
program "ejemplo-binario"
{
#include "functions.dkh"
archivo = "web/misitio.localhost/documentos/informe-2026.pdf"
if not(file.exists(archivo))
{
@http_context<"response/http_status">: 404
@http_context<"response/headers/content-type">: "text/plain;charset=utf-8"
@http_context<"response/output">: "text"
@http_context<"response/text">: "No existe el archivo"
return
}
@http_context<"response/headers/content-type">: "application/pdf"
@http_context<"response/headers/content-disposition">: 'attachment; filename="informe.pdf"'
@http_context<"response/output">: "binary"
@http_context<"response/binary*">: file.rbytes(archivo)
}
```
```text
HTTP/1.1 200 OK
Content-Type: application/pdf
content-disposition: attachment; filename="informe.pdf"
```
Las rutas relativas se resuelven contra la carpeta de trabajo del servidor (la de la instalación), no contra la del programa: por eso la ruta empieza con `web//`. Para obtener la carpeta del sitio en tiempo de ejecución use `@@(@http_context,"$request/headers/document_root")`.
## Códigos de estado
Fije `response/http_status`. En 2.0 el código llega al navegador:
```dkl
#include "dkli.dkh"
#!
program "estado"
{
#include "functions.dkh"
#include "serialize.dkh"
new r { @"success": @true }
@http_context<"response/http_status">: 201
@http_context<"response/headers/content-type">: "application/json;charset=utf-8"
@http_context<"response/output">: "text"
@http_context<"response/text">: to.json(r)
}
```
```text
HTTP/1.1 201 Created
{"success":1}
```
Si un programa termina con una excepción que nadie atrapa, el controlador responde la página `fastcgi/500.dkl` con **estado 500** y el mensaje del error:
```dkl
#include "dkli.dkh"
#!
program "falla"
{
#include "functions.dkh"
do rise_error(0, "Algo salió mal")
}
```
```text
HTTP/1.1 500
Content-Type: text/html;charset=utf-8
500
Excepción no controlada
{1} Error al invocar runscript. ({0} Algo salió mal[Ln= 6]) [http.dkl][Ln= 390]
```
En 1.x esa misma página llegaba con estado 200. Vea [Errores HTTP 500](/es/devkron/2.0/migracion/errores-http.md). La página muestra el detalle del error porque `http.dkl` activa `errordet(@true)`; en producción conviene atrapar los errores en su programa y responder un mensaje propio.
## Redirecciones
Ponga el encabezado `Location` sin cambiar el estado: con 200, nginx convierte la respuesta en un **302**:
```dkl
#include "dkli.dkh"
#!
program "redirige"
{
@http_context<"response/headers/Location">: "/resp/html.dkl"
}
```
```text
HTTP/1.1 302 Moved Temporarily
Location: /resp/html.dkl
```
Para una redirección permanente, fije además `response/http_status` en 301.
## Errores típicos
| Síntoma | Causa y solución |
|---|---|
| La respuesta llega vacía (o con el HTML que produjo el programa) en vez del JSON | Falta `@http_context<"response/output">: "text"`: sin él se responde la salida declarativa del programa y se ignora `response/text` |
| `502 Bad Gateway` al responder un archivo | `output` es `binary` pero `binary` no tiene el arreglo de bytes (por ejemplo, se asignó sin `*`: comprobado, da 502). Use `@http_context<"response/binary*">: file.rbytes(ruta)` |
| `Variable global '@true' no definida` | Falta `#include "functions.dkh"`, que define `@true`, `@false` y `@null` |
| El JavaScript del navegador entra al `error` de su `fetch` donde antes entraba a `success` | En 2.0 el estado 500 sí llega; atrape los errores en el programa y responda `{success:false, message}` con 200 |
| Acentos rotos en el navegador | Falte `charset=utf-8` en el `content-type` |