# Qué es JSON-LD y cómo se usa en una ficha de producto

> Qué es JSON-LD, qué significan @context, @type, @id y @graph, por qué Google lo recomienda y cómo encontrar y comprobar el bloque de tu ficha.

URL: https://clione.ai/es/glosario/json-ld/
Lang: es

Si abres el código fuente de una [ficha de producto](/es/glosario/ficha-de-producto/) y buscas `application/ld+json`, lo que encuentras es JSON-LD: **un bloque de texto que describe la página para las máquinas, separado de lo que ve el cliente**. JSON-LD es el formato, la manera de escribir; las palabras que lleva dentro (producto, precio, marca) son de [Schema.org](/es/glosario/schema-org/), y juntos forman los [datos estructurados](/es/glosario/datos-estructurados/) de la página. Te importa porque es el formato que recomienda Google, también para las fichas que aspiran a [resultados enriquecidos](/es/glosario/resultados-enriquecidos/), y porque, al ir aparte, es fácil que diga una cosa mientras la ficha dice otra.

## Cómo funciona

JSON-LD es una especificación del W3C. Su versión vigente, JSON-LD 1.1, la define como un formato basado en JSON para serializar datos enlazados (_Linked Data_), pensado para encajar en sistemas que ya usan JSON, y es **recomendación del W3C desde el 16 de julio de 2020**. Es un superconjunto de la versión 1.0, de enero de 2014: todo lo que esta permitía sigue ahí.[^w3c-json-ld11] El sitio de la comunidad lo presenta con su nombre largo: _JSON for Linking Data_.[^json-ld-org]

Un documento JSON-LD es JSON normal con unas pocas palabras clave que empiezan por arroba. Las cuatro que verás en una tienda:[^w3c-json-ld11]

- **`@context`**: las reglas para interpretar el documento. En la práctica, `"@context": "https://schema.org"` dice que las palabras que siguen son las de Schema.org.
- **`@type`**: el tipo de lo que se describe, por ejemplo `Product`.
- **`@id`**: un identificador único del nodo, normalmente una dirección web (un IRI). Es lo que permite que otro bloque se refiera a ese mismo producto sin repetirlo; tiene su página propia, el [identificador `@id`](/es/glosario/id-json-ld/).
- **`@graph`**: sirve para expresar un grafo, varios nodos en un mismo bloque. Lo explica la entrada de [`@graph`](/es/glosario/graph/).

En una página web, el bloque va dentro de un elemento `<script type="application/ld+json">`.[^w3c-json-ld11] Google acepta ese elemento tanto en el `<head>` como en el `<body>`, y de los tres formatos que admite (JSON-LD, [microdatos](/es/glosario/microdatos/) y [RDFa](/es/glosario/rdfa/)) **recomienda JSON-LD siempre que el sitio lo permita, porque es el más fácil de implantar y mantener a escala y el que menos errores provoca**.[^google-sd-intro]

El bloque puede llegar escrito en el HTML que sirve el servidor o añadirse después con JavaScript. Google puede procesar los datos estructurados que hay en el DOM cuando renderiza la página, pero avisa de que **el marcado generado dinámicamente puede hacer que los rastreos de Shopping sean menos frecuentes y menos fiables**, un problema para lo que cambia rápido, como el precio y la disponibilidad.[^google-js-sd] Si tu tema o una aplicación inyectan el bloque con JavaScript, la entrada de [renderizado de JavaScript](/es/glosario/renderizado-javascript/) explica qué implica.

El formato sigue vivo. El grupo de trabajo de JSON-LD del W3C tiene un mandato del 6 de enero de 2026 al 31 de enero de 2028 para publicar JSON-LD 1.2, con la recomendación prevista para el cuarto trimestre de 2027, y se compromete a que **cualquier documento válido en JSON-LD 1.1 siga siéndolo en 1.2**.[^w3c-json-ld-charter] Lo que publiques hoy en 1.1 no habrá que reescribirlo por el cambio de versión.

## En una tienda

El bloque de una ficha, reducido a lo esencial. **Ejemplo ficticio**: la tienda, el producto, la dirección y el precio son inventados, y el bloque solo dice lo que esa ficha imaginaria muestra en pantalla.

```html
<script type="application/ld+json">
  {
    "@context": "https://schema.org",
    "@type": "Product",
    "@id": "https://www.example.com/camisa-lino-calella#product",
    "name": "Camisa de lino Calella, azul",
    "image": "https://www.example.com/img/calella-azul.jpg",
    "sku": "CAL-AZ-M",
    "brand": { "@type": "Brand", "name": "Calella" },
    "offers": {
      "@type": "Offer",
      "price": "39.90",
      "priceCurrency": "EUR",
      "availability": "https://schema.org/InStock",
      "url": "https://www.example.com/camisa-lino-calella"
    }
  }
</script>
```

Se lee de arriba abajo. `@context` fija el vocabulario. `@type` dice que es un producto, el tipo [Product](/es/glosario/schema-product/). `@id` le da un nombre estable con el que otros bloques de la página pueden apuntar a él. Las propiedades siguientes son las del vocabulario, y `offers` abre un segundo nodo anidado, de tipo [Offer](/es/glosario/schema-offer/), con el precio, la moneda y la disponibilidad. Fíjate en el precio, con punto decimal, sin símbolo y con la moneda en su propia propiedad: la entrada de Offer explica por qué se escribe así.

Una ficha real suele llevar más de un nodo: la organización, el sitio web, las [migas de pan](/es/glosario/migas-de-pan/) y el producto. Una ficha publicada con Clione, por ejemplo, lleva un solo `@graph` con [Organization](/es/glosario/schema-organization/), [WebSite](/es/glosario/schema-website/), BreadcrumbList y Product, más [FAQPage](/es/glosario/faqpage/) cuando tiene preguntas, y su nodo Product tiene un `@id` estable que convive con el del tema en lugar de duplicarlo.


Pensar que, como el bloque no se ve, puede decir cualquier cosa. Google pide lo contrario con un ejemplo de JSON-LD: si el marcado describe a un artista, el cuerpo de la página tiene que describir a ese mismo artista. Lo que no ve el lector no se marca.[^google-sd-policies]


## Cómo comprobarlo

1. **Abre el código fuente de la ficha** (no el inspector del navegador) y busca `application/ld+json`. Cuenta cuántos bloques hay y qué `@type` declara cada uno: eso es lo que sirve tu servidor.
2. **Pasa la misma URL por la [Prueba de resultados enriquecidos](/es/glosario/prueba-de-resultados-enriquecidos/).** Admite JSON-LD, microdatos y RDFa, te dice qué tipos encuentra con sus errores y sugerencias, y también acepta un fragmento de código pegado.[^rich-results-test]
3. **Compara las dos lecturas.** Si la prueba encuentra un bloque que el código fuente no tenía, lo está añadiendo JavaScript, y para el precio y la disponibilidad eso tiene el coste que describe Google.[^google-js-sd]
4. **Si hay dos nodos de producto, compara sus datos.** Si no dicen lo mismo, al menos uno no representa la página.[^google-sd-policies]

## Concepto cercano: microdatos

Los microdatos son la otra forma habitual de escribir el mismo vocabulario. Forman parte del estándar HTML y añaden grupos de pares nombre-valor **en paralelo al contenido que ya existe**, con atributos como `itemscope`, `itemtype` e `itemprop` sobre las etiquetas visibles.[^whatwg-microdata] JSON-LD hace lo contrario: describe la página en un bloque aparte. Google admite los dos y recomienda JSON-LD.[^google-sd-intro] La diferencia práctica es dónde vive el dato: en microdatos va pegado al texto que lee el cliente, y en JSON-LD se puede cambiar sin tocar la maqueta, con el riesgo de que deje de coincidir con ella.

Para seguir, la [ruta de lectura de datos estructurados](/es/aprender/datos-estructurados/) ordena el resto de términos, y la guía para [auditar los datos estructurados de una ficha](/es/guias/auditar-ficha-de-producto/) aplica estos pasos a una ficha entera.
