Imagina que tienes una tienda online y vendes un móvil a 599 euros con 4,5 estrellas de valoración. Tú lo sabes, tus clientes lo saben… pero Google solo ve texto. No distingue si esos 599 son el precio, un código postal o el número de un artículo.

JSON-LD es la forma de decirle a Google (y a otras IAs) exactamente qué es cada cosa en tu página. Es como ponerle etiquetas a todo: «esto es el precio», «esto es la valoración», «esto es el autor del artículo».

El nombre suena muy técnico (JavaScript Object Notation for Linked Data), pero en la práctica es simplemente un trozo de código que metes en tu web y que los buscadores leen para entender mejor tu contenido.

¿Pero esto no es lo mismo que el Schema?

Casi, pero no exactamente. Es fácil liarse porque se usan como sinónimos, pero hay un matiz importante:

Schema.org es el vocabulario, el diccionario de términos que define qué cosas puedes marcar (productos, artículos, negocios, personas…) y qué propiedades tiene cada una (nombre, precio, fecha, autor…)
JSON-LD es el formato, la manera de escribir ese vocabulario para que los buscadores lo lean

Es como la diferencia entre el español (el idioma, las palabras) y escribirlo en un documento Word (el formato). Schema.org te dice qué puedes decir, JSON-LD te dice cómo escribirlo.

Existen otros formatos para implementar Schema.org, como Microdata o RDFa, pero Google recomienda JSON-LD por su limpieza, porque va en un bloque separado y no ensucia el HTML de tu página.

Si quieres profundizar más en qué es Schema.org y cómo genera los resultados enriquecidos en Google, tienes una guía completa sobre Schema y rich snippets donde un tipo muy inteligente, a la par que guapo y simpático, te lo explica en detalle.

Para qué sirve en la práctica

Lo habrás visto mil veces en Google sin saber que era JSON-LD. Sí, me refiero esas estrellitas de valoración junto a un producto, el precio que aparece directamente en los resultados, las preguntas frecuentes desplegables, los ingredientes y tiempo de preparación de una receta, todo eso.

Eso son los rich snippets o resultados enriquecidos, y se generan gracias a los datos estructurados que le pasas a Google usando JSON-LD.

Los tipos más habituales que puedes marcar son:

Article y BlogPosting: para tus artículos y entradas del blog
Product: productos con precio, disponibilidad y valoraciones
LocalBusiness: negocios locales con dirección, horarios y teléfono
FAQPage: preguntas frecuentes que Google puede mostrar desplegables
Recipe: recetas con ingredientes, tiempo de cocción y calorías
Event: eventos con fecha, lugar y precio de entradas
Person: perfiles de personas (autores, profesionales)
Organization: información de tu empresa o marca
BreadcrumbList: las migas de pan de navegación

Cosas que merecen la pena … y no son algoritmos

La ventaja más clara es visual, tus resultados en Google destacan sobre los demás. Mientras que tu competencia aparece en las SERP con un título y dos líneas de texto, tú apareces con estrellas, precio y disponibilidad. Eso suele ser casi siempre conseguir más clics.

Hay estudios que hablan de mejoras del 15 al 35 % en CTR (porcentaje de clics), pero más allá de números, la lógica es sencilla: un resultado que muestra más información útil atrae más atención.

También ayuda a Google a entender mejor tu contenido. Si tienes un artículo sobre «cómo hacer la tortilla de patatas perfecta», el schema Recipe le dice exactamente que es una receta, quién la escribió, cuánto tiempo lleva y qué ingredientes necesita. Eso facilita que aparezcas cuando alguien busca recetas de tortilla española (la mejor del mundo, ya que estamos).

Para búsquedas por voz, JSON-LD es especialmente útil. Cuando alguien le pregunta a su móvil «¿cuál es el mejor restaurante italiano cerca de mí?», Google tira mucho de datos estructurados para dar la respuesta.

Inconvenientes y limitaciones

Pero no hay magia tampoco porque debes saber igualmente que, por sí mismo, JSON-LD no es un factor de posicionamiento directo. Puedes tener el schema más perfecto del mundo y seguir en la página 10 si tu contenido no vale nada o no satisfaces una búsqueda lo suficiente (esas cosas, ya sí, místicas de los algotirmos).

Además, que implementes datos estructurados no garantiza que Google muestre los rich snippets. Es Google quien decide, y a veces simplemente no le da la gana mostrarlos aunque esté todo bien.

Otro tema importante: tienes que mantenerlo actualizado. Si cambias el precio de un producto en tu tienda pero el JSON-LD sigue mostrando el precio antiguo, puedes tener problemas. Google puede penalizarte si detecta discrepancias entre lo que dices en el schema y lo que muestra la página.

Y cuidado con los plugins. Si ya tienes Yoast o Rank Math generando schema automáticamente, pero además tu tema de WordPress añade lo suyo, y encima WooCommerce mete el de productos, acabas con duplicados que confunden más que ayudan.

De hecho, esto es tan común que al desarrollar la funcionalidad de JSON-LD de VigIA lo primero que hice fue meter un sistema de detección de conflictos. Cuando activas la sección de identidad del sitio el plugin comprueba automáticamente si tienes Yoast, Rank Math, AIOSEO, SEOPress o The SEO Framework activos y te avisa con un mensaje claro antes de que metas la pata generando schemas duplicados de WebSite y Organization. Parece una tontería, pero te ahorra un buen dolor de cabeza.

Por ejemplo, uno de los ajustes que más me gustan a este respecto de SEOPress es el que te ofrece desactivar todos los Schema previos y generar los tuyos totalmente personalizados, fundamental especialmente en tiendas online.

Por último, Google ha ido retirando algunos tipos de resultados enriquecidos. Por ejemplo, FAQPage ahora solo funciona para sitios gubernamentales y de salud autorizados y HowTo también se marcó como obsoleto. Así que no todos los schemas que implementes se van a mostrar como resultado enriquecido, algunos cambian, otros desaparecen. Resumiendo, no es algo de añadir y olvidarte, hay que repasarlo de vez en cuando.

Cómo afecta al SEO

Te lo resumo por si te quieres saltar este punto: JSON-LD no te va a subir posiciones directamente, lo que sí hace es:

Mejorar el CTR: más clics desde los resultados de búsqueda
Ayudar a Google a entenderte: categoriza mejor tu contenido
Conectar con el Knowledge Graph: si usas la propiedad sameAs para enlazar con tu Wikipedia, Wikidata o redes sociales, Google entiende mejor quién eres como entidad
Potenciar las búsquedas por voz: fundamental para respuestas directas

A pesar de ello, el impacto es indirecto pero suele funcionar. Si tu CTR mejora Google interpreta que tu resultado es relevante, así que si Google entiende mejor tu contenido puede mostrarlo en más consultas relevantes.

JSON-LD y las IAs generativas (GEO)

Aquí es donde la cosa se pone interesante de cara al futuro. Con la llegada de ChatGPT Search, Perplexity, Google AI Overviews y similares, aparece un nuevo concepto: GEO (Generative Engine Optimization).

Ya no se trata solo de aparecer en una lista de enlaces, sino de que las IAs te citen en sus respuestas, pues no solo vale con usar el plugin que publiqué para esta cosa.

¿Cómo influye JSON-LD en esto? ¡¡Sorpresa!!… (ninguna)

Las IAs rastrean webs igual que Google, y los datos estructurados les ayudan a entender qué información hay en cada página. Cuando una IA busca información sobre un producto, un negocio o una persona, el schema le facilita encontrar y extraer esos datos.

Microsoft (Bing y Copilot) ya ha confirmado que usa schema markup para alimentar sus respuestas de IA. Y dado que ChatGPT Search utiliza el índice de Bing, lo que optimices para Bing también cuenta para ChatGPT.

Perplexity también favorece contenido estructurado y fácil de procesar. Su sistema RAG (Retrieval-Augmented Generation) funciona mejor cuando puede extraer datos claros y organizados.

En resumen: aunque no hay una garantía de que JSON-LD te haga aparecer en respuestas de IA, sí facilita que tu información sea comprendida y potencialmente citada. Es una inversión de futuro.

Pero hay un matiz importante que los plugins SEO tradicionales no cubren. Rank Math, Yoast y compañía generan schema pensando en Google: artículos, productos, negocios, preguntas frecuentes. Está muy bien para rich snippets, pero no le dicen a las IAs dónde encontrar tu contenido en formato que puedan procesar fácilmente.

Aquí es donde entra la parte de descubrimiento de IA de VigIA. Además de generar el Schema clásico de identidad del sitio (WebSite, Organization o Person con perfiles sociales y sameAs) VigIA añade al JSON-LD unas propiedades de tipo ReadAction que apuntan directamente a tus archivos llms.txt, llms-full.txt y a los endpoints Markdown for Agents de tu web.

Vamos, que le estás diciendo a las IAs algo como, «oye, aquí tienes mi contenido ya preparado para que lo leas sin tener que tragarte todo el HTML».

Ningún plugin SEO hace esto ahora mismo, porque están pensados para buscadores, no para agentes de IA. Y es una señal estructurada que complementa perfectamente al schema SEO que ya tengas configurado.

Estructura básica de JSON-LD

Un bloque de JSON-LD siempre va dentro de una etiqueta script con tipo application/ld+json:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Título de tu artículo",
  "author": {
    "@type": "Person",
    "name": "Tu Nombre"
  },
  "datePublished": "2025-01-05"
}
</script>

Los elementos clave son:

@context: siempre https://schema.org, indica qué vocabulario usas.
@type: el tipo de contenido (Article, Product, LocalBusiness…).
@id: un identificador único (opcional pero recomendable).
El resto de propiedades dependen del tipo que uses.

Ejemplo de producto para tienda online

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Camiseta Ayuda WordPress Edición Especial",
  "image": "https://tutienda.com/camiseta-ayudawp.jpg",
  "description": "Camiseta de algodón 100% con el logo de AyudaWP.com",
  "brand": {
    "@type": "Brand",
    "name": "AyudaWP"
  },
  "offers": {
    "@type": "Offer",
    "price": "29.99",
    "priceCurrency": "EUR",
    "availability": "https://schema.org/InStock",
    "url": "https://tutienda.com/camiseta-ayudawp"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "reviewCount": "47"
  }
}
</script>

Ejemplo de negocio local

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "LocalBusiness",
  "name": "Restaurante El Chuletón",
  "image": "https://restaurante.com/fachada.jpg",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "Plaza El Grande 15",
    "addressLocality": "Ávila",
    "postalCode": "05600",
    "addressCountry": "ES"
  },
  "telephone": "+34 91 123 45 67",
  "openingHours": "Mo-Su 13:00-23:00",
  "priceRange": "€€",
  "geo": {
    "@type": "GeoCoordinates",
    "latitude": "40.4168",
    "longitude": "-3.7038"
  }
}
</script>

Ejemplo de artículo de blog

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Guía completa de JSON-LD para WordPress",
  "author": {
    "@type": "Person",
    "name": "Fernando Tellado",
    "url": "https://ayudawp.com/author/fernando-tellado/"
  },
  "datePublished": "2025-01-05",
  "dateModified": "2025-01-05",
  "publisher": {
    "@type": "Organization",
    "name": "AyudaWP",
    "logo": {
      "@type": "ImageObject",
      "url": "https://ayudawp.com/logo.png"
    }
  },
  "image": "https://ayudawp.com/wp-content/uploads/2025/12/logo-ayudawp-com-2-lineas-negro-peque.png",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://ayudawp.com/json-ld/"
  }
}
</script>

Ejemplo de JSON-LD con AI Discovery

Este es un ejemplo diferente a los anteriores porque no busca generar rich snippets en Google, sino hacer que las IAs descubran tus contenidos preparados para ellas. Usa propiedades ReadAction dentro de potentialAction para señalar dónde están tus archivos llms.txt y tus endpoints en formato markdown:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "WebSite",
      "@id": "https://tudominio.com/#website",
      "url": "https://tudominio.com/",
      "name": "Tu sitio web",
      "publisher": {
        "@id": "https://tudominio.com/#identity"
      },
      "potentialAction": [
        {
          "@type": "SearchAction",
          "target": {
            "@type": "EntryPoint",
            "urlTemplate": "https://tudominio.com/?s={search_term_string}"
          },
          "query-input": "required name=search_term_string"
        },
        {
          "@type": "ReadAction",
          "target": "https://tudominio.com/llms.txt",
          "name": "LLMs.txt",
          "description": "Machine-readable content index for LLMs"
        },
        {
          "@type": "ReadAction",
          "target": "https://tudominio.com/{slug}.md",
          "name": "Markdown for Agents",
          "description": "Individual posts served as optimized markdown via .md URL endpoints"
        }
      ]
    },
    {
      "@type": "Organization",
      "@id": "https://tudominio.com/#identity",
      "name": "Tu empresa",
      "url": "https://tudominio.com/",
      "logo": {
        "@type": "ImageObject",
        "@id": "https://tudominio.com/#logo",
        "url": "https://tudominio.com/logo.png"
      },
      "sameAs": [
        "https://twitter.com/tucuenta",
        "https://es.wikipedia.org/wiki/Tu_empresa"
      ]
    }
  ]
}
</script>

Fíjate en que usa la estructura @graph para incluir varios nodos relacionados entre sí (el sitio web y la entidad propietaria), algo más avanzado que los ejemplos anteriores pero que es lo que generan los plugins cuando quieren representar relaciones entre entidades.

Si te parece mucho lío hacerlo a mano, VigIA genera exactamente esto de forma automática desde su pestaña de JSON-LD, con vista previa en tiempo real para que veas lo que va a generar antes de activarlo.

Cómo implementar JSON-LD en WordPress

Tienes 3 opciones principales: plugins, código personalizado o manualmente.

Con plugins

Rank Math es probablemente la mejor opción entre los plugins SEO ahora mismo. Incluye más de 18 tipos de schema, un validador integrado, y puedes poner varios schemas en la misma página. En cada entrada o página tienes un panel donde seleccionas el tipo y rellenas los campos.
Yoast SEO genera schemas automáticamente para artículos, organización, páginas y migas de pan. Es más limitado que Rank Math en la versión gratuita, pero si ya lo usas, cubre lo básico.
Schema Pro es un plugin de pago específico para esto. Si ya usas Yoast para SEO pero necesitas más control sobre el schema, es una buena combinación. Tiene 13 tipos y automatización bastante potente.

Si lo que te interesa es el ángulo IA más que el SEO clásico, VigIA tiene un generador de JSON-LD pensado específicamente para eso. No compite con Rank Math ni Yoast, los complementa.

La parte de identidad del sitio genera el mismo Schema de WebSite y Organization/Person con perfiles sociales, pero la parte de descubrimiento IA añade los punteros ReadAction a tus archivos llms.txt y endpoints de Markdown para agentes, que es algo que ningún plugin SEO incluye de momento.

Además detecta si ya tienes un plugin SEO activo y te avisa para que no dupliques el schema de identidad. Es gratuito, por si aún no lo sabías.

El truco con los plugins es configurar bien los ajustes generales (información de la empresa, logo, redes sociales) y luego revisar que no haya conflictos con otros plugins o con tu tema.

Con código personalizado

Si prefieres tener control total o el plugin no cubre tu situación concreta, puedes añadir JSON-LD mediante el hook wp_head. Este código iría en el functions.php de tu tema hijo, en un plugin de snippets o, mucho mejor, como plugin personalizado o plugin MU, pero tú verás:

<?php
/**
 * Añade schema de Organization en la página de inicio
 */
function ayudawp_schema_organization() {
    // Solo en la página de inicio
    if ( ! is_front_page() ) {
        return;
    }
    
    $schema = array(
        '@context'  => 'https://schema.org',
        '@type'     => 'Organization',
        'name'      => get_bloginfo( 'name' ),
        'url'       => home_url( '/' ),
        'logo'      => array(
            '@type' => 'ImageObject',
            'url'   => 'https://tudominio.com/logo.png',
        ),
        'sameAs'    => array(
            'https://www.facebook.com/tupagina',
            'https://twitter.com/tucuenta',
            'https://www.linkedin.com/company/tuempresa',
        ),
    );
    
    echo '<script type="application/ld+json">' . 
         wp_json_encode( $schema, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE ) . 
         '</script>' . "\n";
}
add_action( 'wp_head', 'ayudawp_schema_organization' );
?>

Para artículos individuales, el código sería algo así:

<?php
/**
 * Añade schema de BlogPosting en entradas individuales
 */
function ayudawp_schema_blogposting() {
    // Solo en entradas individuales
    if ( ! is_single() ) {
        return;
    }
    
    global $post;
    
    // Obtener imagen destacada
    $imagen = get_the_post_thumbnail_url( $post->ID, 'full' );
    if ( ! $imagen ) {
        $imagen = 'https://tudominio.com/imagen-por-defecto.jpg';
    }
    
    // Obtener autor
    $autor_nombre = get_the_author_meta( 'display_name', $post->post_author );
    $autor_url    = get_author_posts_url( $post->post_author );
    
    $schema = array(
        '@context'       => 'https://schema.org',
        '@type'          => 'BlogPosting',
        'headline'       => get_the_title(),
        'image'          => $imagen,
        'datePublished'  => get_the_date( 'c' ),
        'dateModified'   => get_the_modified_date( 'c' ),
        'author'         => array(
            '@type' => 'Person',
            'name'  => $autor_nombre,
            'url'   => $autor_url,
        ),
        'publisher'      => array(
            '@type' => 'Organization',
            'name'  => get_bloginfo( 'name' ),
            'logo'  => array(
                '@type' => 'ImageObject',
                'url'   => 'https://tudominio.com/logo.png',
            ),
        ),
        'mainEntityOfPage' => array(
            '@type' => 'WebPage',
            '@id'   => get_permalink(),
        ),
    );
    
    echo '<script type="application/ld+json">' . 
         wp_json_encode( $schema, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE ) . 
         '</script>' . "\n";
}
add_action( 'wp_head', 'ayudawp_schema_blogposting' );
?>

A mano

Si solo necesitas añadir schema en unas pocas páginas específicas, puedes hacerlo directamente editando el HTML. Tienes varias opciones:

En el header.php de tu tema: pega el código JSON-LD antes de cerrar la etiqueta </head>.
Con un plugin de códigos, como los que vimos en la comparativa de plugins de snippets de código.
En campos personalizados: crea un campo para pegar el JSON-LD y luego muéstralo con código en el tema.

Esta opción es la menos escalable, pero funciona si tienes pocas páginas que necesiten schema específico.

Cómo comprobar que funciona

Una vez implementado toca verificar que está bien. Hay tres herramientas principales:

Rich Results Test de Google

search.google.com/test/rich-results

Es la herramienta oficial de Google. Metes la URL de tu página y te dice qué tipos de schema detecta, si hay errores, y te muestra una vista previa de cómo podría aparecer en resultados. Solo valida los tipos que Google admite para rich results.

Schema Markup Validator

validator.schema.org

Valida la sintaxis de cualquier tipo de schema, no solo los que usa Google. Es útil para asegurarte de que no hay errores en el código aunque Google no vaya a mostrar resultados enriquecidos para ese tipo.

Google Search Console

En el apartado «Mejoras» puedes ver el estado de tus datos estructurados a lo largo del tiempo. Te muestra cuántas páginas tienen schema válido, cuáles tienen errores, y la evolución histórica.

Mi consejo es:

Desarrolla y prueba el schema en Rich Results Test.
Valida la sintaxis completa en Schema Markup Validator.
Sube los cambios y espera unos días.
Revisa en Search Console que todo esté correcto.

Y cada vez que actualices el tema, cambies de plugin SEO o hagas cambios importantes, vuelve a comprobar que el schema sigue funcionando.

Terminamos

JSON-LD no es la panacea del SEO pero es una herramienta que deberías tener en tu arsenal.

Ayuda a Google (y cada vez más a las IAs) a entender tu contenido, te da la posibilidad de destacar en resultados con información extra, y es relativamente fácil de implementar con los plugins actuales.

Si usas Rank Math o Yoast, ya tienes lo básico cubierto. Solo asegúrate de configurar bien la información de tu empresa, revisar que no haya conflictos con otros plugins, y validar de vez en cuando que todo sigue funcionando.

Y si necesitas algo más específico, el código personalizado puedes usar un código personalizado. Lo importante es que lo que declares en el schema coincida siempre con lo que muestra la página, y que no te obsesiones, porque es una ayuda, no otro algoritmo mágico de posicionamiento.