Hasta {MAX_KEYS} datos. Las claves se pasan a minúsculas y admiten letras,
números, guiones y guiones bajos.
setSigning(e.target.checked)} />
{signing &&
Regenerá el secreto cuando termines de probar. Acá se usa
solo dentro de tu navegador y no se envía a ningún lado, pero al pegarlo en
una página quedó fuera de tu servidor. Regenerarlo desde{' '}
Configuración de la Agenda → Desarrolladores lo vuelve a dejar seguro.
setSecret(e.target.value)} placeholder="pegá tu secreto de firma" aria-label="Secreto de firma" />
Texto que se firma
{canonical || 'todavía no hay datos para firmar'}
Las claves van ordenadas alfabéticamente y los valores sin codificar.
Es el mismo texto que tiene que armar tu servidor.
{sig &&
sig = {sig}
}
}
Enlace resultante
{url || 'escribí el uuid de tu agenda para generar el enlace'}
;
};
## Qué hace
Podés insertar el calendario de una agenda dentro de otro sitio web. Quien lo inserta puede dejar el nombre, el email y el teléfono del cliente ya completos, y guardar información propia en cada reserva (por ejemplo un número de orden interno).
El cliente reserva sin salir del sitio donde estaba.
## Cuándo usarlo
Cuando trabajás con una plataforma o un partner que quiere que sus usuarios reserven sin salir de su sitio: un marketplace, un portal de pacientes, una app propia, etc.
Si solo compartís el link o el QR, no necesitás esto: alcanza con [Compartir tu link de reserva](/primeros-pasos/compartir-link-de-reserva) o [Códigos QR](/publico/codigos-qr).
## Dónde encontrarlo
**Agenda → Configuración → Calendario embebido.**
Ahí encontrás:
* El código para copiar e insertar en tu sitio.
* El interruptor para exigir que los datos del enlace vengan firmados.
* El secreto de firma (aparece difuminado hasta que lo revelás), con opción de regenerarlo.
## Datos ya completos
El sitio que inserta el calendario puede dejar el nombre, el email y el teléfono cargados. Esos campos aparecen en gris y no se pueden editar en Turnito, para que coincidan con los datos del otro sistema.
Si algún dato viene mal formado, ese campo queda editable y el resto sigue bloqueado.
## Información propia en la reserva
El sitio que inserta el calendario puede mandar información suya junto con la reserva (un ID interno, el origen del tráfico, etc.). Cuando la reserva la tiene, la ves:
* En el detalle de la reserva, bajo **Datos externos**.
* En la exportación de reservas, como columnas **Dato externo: …**.
Si la reserva no trae esa información, no aparece nada nuevo en la pantalla ni en el Excel.
## Seguridad
El **secreto de firma** sirve para que quien programa tu sitio firme los datos del enlace desde su servidor. Así un visitante no puede cambiar la URL del calendario y alterar nombre, email o esa información propia.
Conviene activar **Exigir firma** cuando la integración ya esté andando: con eso activo, Turnito rechaza los enlaces con datos sin firma válida.
**Regenerar el secreto** invalida todos los enlaces firmados que ya estén publicados. Después tenés que pasarle el secreto nuevo a quien programa tu sitio.
### Cómo se genera la firma
Esta parte es para quien programa tu sitio. Pasale este enlace.
La firma se calcula **en el servidor**, nunca en el navegador: si el secreto viaja al navegador, cualquiera lo puede leer y la firma deja de servir.
Tomá los parámetros `prefill_*` y `metadata_*` que vayas a mandar, más `exp` si usás vencimiento. Ordenalos por nombre alfabéticamente, escapá nombre y valor por separado, y unilos con `&`.
El escapado es percent-encoding RFC 3986: se codifica todo salvo `A-Za-z0-9-._~`, en hexadecimal mayúscula. Es `rawurlencode()` en PHP y `quote(s, safe='')` en Python. En JavaScript, `encodeURIComponent` deja sin escapar `!'()*` y hay que completarlo — el ejemplo de abajo ya lo hace.
```
Parámetros:
prefill_name=Juan Pérez
prefill_email=juan@acme.com
metadata_internal_id=ORD-1234
exp=1753900000
Texto a firmar:
exp=1753900000&metadata_internal_id=ORD-1234&prefill_email=juan%40acme.com&prefill_name=Juan%20P%C3%A9rez
```
No incluyas `embed` ni ningún otro parámetro que no sea `prefill_*`, `metadata_*` o `exp`.
`sig = HMAC-SHA256(secreto, texto)` en hexadecimal minúscula. Agregá el resultado a la URL como `&sig=...`.
```js theme={null}
const crypto = require('crypto');
const buildSignedEmbedUrl = (agendaUuid, secret, params) => {
const signable = {};
for (const [key, value] of Object.entries(params || {})) {
if (key === 'exp' || key.startsWith('prefill_') || key.startsWith('metadata_')) {
if (value !== null && value !== undefined && value !== '') signable[key] = String(value);
}
}
// encodeURIComponent deja sin escapar !'()*, que RFC 3986 sí escapa.
const enc = (s) =>
encodeURIComponent(s).replace(/[!'()*]/g, (c) =>
'%' + c.charCodeAt(0).toString(16).toUpperCase());
const canonical = Object.keys(signable).sort()
.map((key) => `${enc(key)}=${enc(signable[key])}`)
.join('&');
const sig = crypto.createHmac('sha256', secret).update(canonical, 'utf8').digest('hex');
const qs = new URLSearchParams({ embed: '1', ...signable, sig });
return `https://turnito.app/c/${agendaUuid}?${qs.toString()}`;
};
```
```python theme={null}
import hashlib
import hmac
from urllib.parse import quote, urlencode
def build_signed_embed_url(agenda_uuid: str, secret: str, params: dict) -> str:
signable = {
key: str(value)
for key, value in (params or {}).items()
if value not in (None, "")
and (key == "exp" or key.startswith("prefill_") or key.startswith("metadata_"))
}
enc = lambda s: quote(s, safe="")
canonical = "&".join(f"{enc(key)}={enc(signable[key])}" for key in sorted(signable))
sig = hmac.new(secret.encode("utf-8"), canonical.encode("utf-8"), hashlib.sha256).hexdigest()
query = urlencode({"embed": "1", **signable, "sig": sig})
return f"https://turnito.app/c/{agenda_uuid}?{query}"
```
```php theme={null}
$value) {
if ($value === null || $value === '') continue;
if ($key === 'exp' || str_starts_with($key, 'prefill_') || str_starts_with($key, 'metadata_')) {
$signable[$key] = (string) $value;
}
}
ksort($signable);
$parts = [];
foreach ($signable as $key => $value) {
// rawurlencode ya es RFC 3986.
$parts[] = rawurlencode($key) . '=' . rawurlencode($value);
}
$canonical = implode('&', $parts);
$sig = hash_hmac('sha256', $canonical, $secret);
$query = http_build_query(array_merge(['embed' => '1'], $signable, ['sig' => $sig]));
return "https://turnito.app/c/{$agendaUuid}?{$query}";
}
```
Con el secreto `mi-secreto` y los parámetros del paso anterior, el resultado tiene que ser exactamente:
```
407a8a40d71bdf1d690b65219033cfa29a7869c40318244bdcf1fff8e1c2f4ba
```
Si te da otra cosa, revisá el paso 1: casi siempre es orden de claves, valores sin escapar, o parámetros de más metidos en el texto.
Agregá `exp` con un timestamp Unix. Pasada esa hora, Turnito rechaza el enlace. Conviene usar ventanas cortas, de minutos u horas, no de días.
Escapar los valores no es un detalle cosmético. Si mandás un valor sin escapar que contenga `&clave=` —por ejemplo una URL de retorno—, alguien puede partirlo e inyectar un dato firmado que vos nunca pusiste, como el email del cliente.
## Probalo acá
Armá el enlace con tus propios datos y mirá cómo queda el calendario antes de pasárselo a quien programa tu sitio.
## Páginas relacionadas
* [La página de reserva](/publico/pagina-de-reserva)
* [Códigos QR](/publico/codigos-qr)
* [Compartir tu link de reserva](/primeros-pasos/compartir-link-de-reserva)
* [API pública](/api/index)