Schema Endpoints: Datos Estructurados que la IA Puede Leer de un Vistazo [2026]

TLDR: Un schema endpoint es una URL unica que sirve todo el grafo de datos estructurados de tu web en formato JSON-LD. En lugar de obligar a los agentes de IA a crawlear cientos de paginas para entender tu sitio, les das un solo fichero con toda la informacion. Yoast lanzo su Schema Aggregation en marzo de 2026 junto con Microsoft NLWeb, y el concepto esta cambiando como se indexa la web. En esta guia te explicamos que es, como implementarlo en WordPress, Next.js y sitios custom, y por que es clave para SEO y GEO en 2026.

Que son los datos estructurados y por que importan en la era de la IA

Los datos estructurados son fragmentos de codigo (normalmente JSON-LD) que describes en tu HTML para decirle a las maquinas que significa cada elemento de tu pagina. Un titulo no es solo un <h1>: es el name de un Article. Un precio no es solo un numero: es el price de un Product con una currency.

Hasta 2024, los datos estructurados servian principalmente para conseguir rich snippets en Google: estrellas de reviews, precios, FAQs desplegables, recetas con imagen. Eran utiles, pero opcionales.

En 2026, la situacion es radicalmente distinta:

La razon del cambio es sencilla: los LLMs necesitan datos limpios y estructurados para generar respuestas precisas. Cuando un usuario pregunta a ChatGPT "cual es el mejor restaurante italiano en Madrid con terraza", el modelo busca fuentes que tengan esa informacion en formato legible por maquina. Si tu restaurante tiene un schema Restaurant con servesCuisine: "Italian", address en Madrid y amenityFeature: "terrace", tienes muchas mas probabilidades de aparecer citado.

El problema es que hasta ahora, para obtener todos esos datos, un agente IA tenia que crawlear cada pagina individual de tu sitio. Y eso es lento, costoso computacionalmente y propenso a errores.

Ahi es donde entran los schema endpoints.

Que es un schema endpoint (y que es un schema map)

Un schema endpoint es una URL unica de tu sitio web que devuelve, en un solo documento JSON-LD, el grafo completo de datos estructurados de todo tu sitio.

Imagina que tienes un blog con 200 articulos. Hoy, cada articulo tiene su propio bloque <script type="application/ld+json"> con datos como titulo, autor, fecha, descripcion. Para que un agente IA conozca todos tus articulos, tiene que visitar las 200 URLs.

Con un schema endpoint, sirves una unica URL (por ejemplo, https://tusitio.com/schema.json o https://tusitio.com/schema-endpoint) que contiene los datos de los 200 articulos en un solo documento.

Schema Map vs Schema Endpoint

Los terminos se usan a veces como sinonimos, pero hay un matiz:

Un schema map es util para sitios muy grandes. En lugar de meter 50.000 productos en un solo JSON, el schema map lista las URLs de varios schema endpoints tematicos:

1{
2  "@context": "https://schema.org",
3  "@type": "DataFeed",
4  "name": "Schema Map de MiTienda",
5  "dateModified": "2026-04-13",
6  "dataFeedElement": [
7    {
8      "@type": "DataFeed",
9      "name": "Productos - Electronica",
10      "url": "https://mitienda.com/schema/productos-electronica.json"
11    },
12    {
13      "@type": "DataFeed",
14      "name": "Productos - Hogar",
15      "url": "https://mitienda.com/schema/productos-hogar.json"
16    },
17    {
18      "@type": "DataFeed",
19      "name": "Articulos del Blog",
20      "url": "https://mitienda.com/schema/articulos.json"
21    },
22    {
23      "@type": "DataFeed",
24      "name": "FAQs",
25      "url": "https://mitienda.com/schema/faqs.json"
26    }
27  ]
28}

Yoast Schema Aggregation y Microsoft NLWeb: el punto de inflexion

En marzo de 2026, dos eventos convergieron y pusieron los schema endpoints en el centro de la conversacion SEO:

Yoast Schema Aggregation

Joost de Valk, fundador de Yoast (ahora en Newfold Digital), habia venido hablando desde 2022 sobre la necesidad de optimizar como los crawlers consumen datos de las webs. Su articulo de octubre de 2022 sobre optimizar el crawleo ya planteaba que servir toda la informacion relevante de forma centralizada seria mas eficiente que obligar a los bots a visitar cada URL.

En marzo de 2026, Yoast lanzo oficialmente Schema Aggregation: una funcion de Yoast SEO Premium que genera automaticamente un schema endpoint en /schema-endpoint/ para cualquier sitio WordPress. Este endpoint:

• Agrega todos los datos JSON-LD de todas las paginas del sitio
• Actualiza automaticamente cuando se publica o modifica contenido
• Soporta paginacion para sitios grandes (mas de 1.000 elementos)
• Incluye metadatos de dateModified para actualizaciones incrementales
• Sigue el estandar schema.org con @graph para representar el grafo completo

La implementacion de Yoast es elegante porque se apoya en todo el schema que ya generaba el plugin para cada pagina individual. Simplemente lo agrega en un unico punto.

Microsoft NLWeb

De forma casi simultanea, Microsoft anuncio NLWeb (Natural Language Web), un protocolo que permite a los sitios web responder consultas en lenguaje natural directamente. NLWeb tiene varios componentes, pero uno de los fundamentales es la capacidad de servir datos estructurados de forma agregada para que los agentes IA no necesiten crawlear pagina por pagina.

NLWeb y los schema endpoints de Yoast son complementarios:

La convergencia no es casualidad. Joost de Valk trabajo directamente con Microsoft en la integracion de NLWeb con Yoast, creando un ecosistema donde los datos estructurados son la capa fundamental sobre la que se construye la web conversacional.

Si quieres profundizar en como ChatGPT y otros LLMs usan estos datos para SEO, te recomendamos nuestra guia de ChatGPT para SEO.

Schema per-page vs schema agregado: diferencias clave

Es importante entender que los schema endpoints no reemplazan el schema per-page. Son complementarios.

Schema per-page (lo que ya haces)

Cada pagina de tu web incluye su propio bloque JSON-LD:

1<!-- En /blog/mi-articulo -->
2<script type="application/ld+json">
3{
4  "@context": "https://schema.org",
5  "@type": "Article",
6  "headline": "Como optimizar tu web para IA",
7  "author": {
8    "@type": "Person",
9    "name": "Ana Garcia"
10  },
11  "datePublished": "2026-04-13",
12  "description": "Guia practica para hacer tu web legible por LLMs"
13}
14</script>

Schema agregado (el schema endpoint)

Un unico documento con todos los datos:

1{
2  "@context": "https://schema.org",
3  "@graph": [
4    {
5      "@type": "WebSite",
6      "@id": "https://tusitio.com/#website",
7      "name": "Tu Sitio",
8      "url": "https://tusitio.com",
9      "description": "Descripcion del sitio"
10    },
11    {
12      "@type": "Organization",
13      "@id": "https://tusitio.com/#organization",
14      "name": "Tu Empresa",
15      "url": "https://tusitio.com",
16      "logo": "https://tusitio.com/logo.png",
17      "sameAs": [
18        "https://twitter.com/tuempresa",
19        "https://linkedin.com/company/tuempresa"
20      ]
21    },
22    {
23      "@type": "Article",
24      "@id": "https://tusitio.com/blog/articulo-1/#article",
25      "headline": "Primer articulo",
26      "datePublished": "2026-01-15",
27      "author": { "@id": "https://tusitio.com/#author-ana" }
28    },
29    {
30      "@type": "Article",
31      "@id": "https://tusitio.com/blog/articulo-2/#article",
32      "headline": "Segundo articulo",
33      "datePublished": "2026-02-20",
34      "author": { "@id": "https://tusitio.com/#author-ana" }
35    },
36    {
37      "@type": "FAQPage",
38      "@id": "https://tusitio.com/faq/#faqpage",
39      "mainEntity": [
40        {
41          "@type": "Question",
42          "name": "Que servicios ofreceis?",
43          "acceptedAnswer": {
44            "@type": "Answer",
45            "text": "Ofrecemos consultoria IA, desarrollo web y automatizacion."
46          }
47        }
48      ]
49    }
50  ]
51}

Comparativa directa

Tipos de schema.org que importan para IA

No todos los tipos de schema.org son igualmente relevantes para los agentes IA. Estos son los que mas impacto tienen en 2026:

Tier 1: Imprescindibles

Tier 2: Muy recomendados

Tier 3: Utiles para nichos

Por que FAQPage y HowTo son criticos para IA

Los LLMs buscan respuestas directas. Cuando un FAQPage tiene preguntas y respuestas explicitamente marcadas, el modelo puede:

1. Extraer la respuesta exacta sin interpretar texto libre
2. Citar tu web como fuente de la respuesta
3. Incluir multiples preguntas de tu FAQ en una sola respuesta

Lo mismo ocurre con HowTo: los pasos numerados y las herramientas necesarias son informacion que los agentes IA pueden procesar de forma nativa.

Si quieres entender como los agentes IA usan esta informacion en la practica, el equipo de www.javadex.es ha documentado implementaciones reales de schema endpoints en proyectos de produccion.

Implementacion en WordPress (con Yoast)

Si tu sitio corre en WordPress, la implementacion mas sencilla es con Yoast SEO Premium (a partir de la version 24.0, marzo 2026).

Paso 1: Activar Schema Aggregation

1WordPress Admin > Yoast SEO > Ajustes > Schema > Schema Aggregation

Activa el toggle "Generar schema endpoint". Yoast creara automaticamente la URL:

1https://tusitio.com/schema-endpoint/

Paso 2: Verificar el output

Visita la URL del endpoint y comprueba que devuelve un JSON-LD valido. Deberia incluir:

• El nodo WebSite con informacion del sitio
• El nodo Organization o Person (segun tu configuracion)
• Todos los Article, Product, FAQPage, etc. de tu contenido
• Referencias cruzadas con @id

Paso 3: Configurar que tipos incluir

En los ajustes de Yoast, puedes seleccionar que tipos de contenido incluir en el schema endpoint:

• Posts (Article/BlogPosting)
• Paginas (WebPage)
• Productos (Product, si usas WooCommerce)
• FAQs
• Custom post types

Paso 4: Anadir el endpoint a robots.txt y llms.txt

Asegurate de que los crawlers y agentes IA pueden encontrar tu endpoint:

1# robots.txt
2Sitemap: https://tusitio.com/sitemap.xml
3Schema-Endpoint: https://tusitio.com/schema-endpoint/
4 
5# llms.txt
6> Schema endpoint con datos estructurados agregados
7Schema: https://tusitio.com/schema-endpoint/

Paso 5: Declarar en el sitemap

Aunque no es obligatorio, puedes anadir una referencia al schema endpoint en tu sitemap.xml:

1<url>
2  <loc>https://tusitio.com/schema-endpoint/</loc>
3  <lastmod>2026-04-13</lastmod>
4  <changefreq>daily</changefreq>
5  <priority>0.9</priority>
6</url>

Implementacion en Next.js (App Router)

Para sitios construidos con Next.js (como los que desarrolla el equipo de www.javadex.es), necesitas generar el schema endpoint manualmente. La ventaja es que tienes control total sobre el output.

Paso 1: Crear la API route

1// app/schema-endpoint/route.ts
2import { NextResponse } from 'next/server'
3import { getAllPosts } from '@/lib/data'
4import { getAllProducts } from '@/lib/data'
5 
6export async function GET() {
7  const posts = await getAllPosts()
8  const products = await getAllProducts()
9 
10  const schemaGraph = {
11    "@context": "https://schema.org",
12    "@graph": [
13      // WebSite
14      {
15        "@type": "WebSite",
16        "@id": "https://tusitio.com/#website",
17        "name": "Tu Sitio",
18        "url": "https://tusitio.com",
19        "description": "Descripcion de tu sitio",
20        "inLanguage": "es-ES",
21        "potentialAction": {
22          "@type": "SearchAction",
23          "target": "https://tusitio.com/buscar?q={search_term_string}",
24          "query-input": "required name=search_term_string"
25        }
26      },
27 
28      // Organization
29      {
30        "@type": "Organization",
31        "@id": "https://tusitio.com/#organization",
32        "name": "Tu Empresa",
33        "url": "https://tusitio.com",
34        "logo": {
35          "@type": "ImageObject",
36          "url": "https://tusitio.com/logo.png"
37        },
38        "sameAs": [
39          "https://twitter.com/tuempresa",
40          "https://linkedin.com/company/tuempresa",
41          "https://github.com/tuempresa"
42        ]
43      },
44 
45      // Articles (del blog)
46      ...posts.map(post => ({
47        "@type": "Article",
48        "@id": `https://tusitio.com/blog/${post.slug}/#article`,
49        "headline": post.title,
50        "description": post.excerpt,
51        "datePublished": post.date,
52        "dateModified": post.lastModified || post.date,
53        "author": { "@id": "https://tusitio.com/#organization" },
54        "publisher": { "@id": "https://tusitio.com/#organization" },
55        "isPartOf": { "@id": "https://tusitio.com/#website" },
56        "mainEntityOfPage": `https://tusitio.com/blog/${post.slug}`,
57        "keywords": post.keywords?.join(", ")
58      })),
59 
60      // Products (si aplica)
61      ...products.map(product => ({
62        "@type": "Product",
63        "@id": `https://tusitio.com/producto/${product.slug}/#product`,
64        "name": product.name,
65        "description": product.description,
66        "offers": {
67          "@type": "Offer",
68          "price": product.price,
69          "priceCurrency": "EUR",
70          "availability": "https://schema.org/InStock"
71        }
72      }))
73    ]
74  }
75 
76  return NextResponse.json(schemaGraph, {
77    headers: {
78      'Content-Type': 'application/ld+json',
79      'Cache-Control': 'public, max-age=3600, s-maxage=86400',
80      'X-Robots-Tag': 'noindex'
81    }
82  })
83}

Paso 2: Generar un schema map (para sitios grandes)

Si tienes mas de 1.000 elementos, crea un schema map que apunte a endpoints paginados:

1// app/schema-map/route.ts
2import { NextResponse } from 'next/server'
3 
4export async function GET() {
5  const schemaMap = {
6    "@context": "https://schema.org",
7    "@type": "DataFeed",
8    "name": "Schema Map",
9    "dateModified": new Date().toISOString(),
10    "dataFeedElement": [
11      {
12        "@type": "DataFeed",
13        "name": "Articulos - Pagina 1",
14        "url": "https://tusitio.com/schema-endpoint/articles?page=1"
15      },
16      {
17        "@type": "DataFeed",
18        "name": "Articulos - Pagina 2",
19        "url": "https://tusitio.com/schema-endpoint/articles?page=2"
20      },
21      {
22        "@type": "DataFeed",
23        "name": "Productos",
24        "url": "https://tusitio.com/schema-endpoint/products"
25      },
26      {
27        "@type": "DataFeed",
28        "name": "FAQs",
29        "url": "https://tusitio.com/schema-endpoint/faqs"
30      }
31    ]
32  }
33 
34  return NextResponse.json(schemaMap, {
35    headers: {
36      'Content-Type': 'application/ld+json',
37      'Cache-Control': 'public, max-age=3600'
38    }
39  })
40}

Paso 3: Endpoint paginado

1// app/schema-endpoint/articles/route.ts
2import { NextResponse } from 'next/server'
3import { getAllPosts } from '@/lib/data'
4 
5const ITEMS_PER_PAGE = 500
6 
7export async function GET(request: Request) {
8  const { searchParams } = new URL(request.url)
9  const page = parseInt(searchParams.get('page') || '1')
10 
11  const allPosts = await getAllPosts()
12  const start = (page - 1) * ITEMS_PER_PAGE
13  const posts = allPosts.slice(start, start + ITEMS_PER_PAGE)
14 
15  const schema = {
16    "@context": "https://schema.org",
17    "@type": "DataFeed",
18    "name": `Articulos - Pagina ${page}`,
19    "dateModified": new Date().toISOString(),
20    "dataFeedElement": posts.map(post => ({
21      "@type": "Article",
22      "@id": `https://tusitio.com/blog/${post.slug}/#article`,
23      "headline": post.title,
24      "description": post.excerpt,
25      "datePublished": post.date,
26      "url": `https://tusitio.com/blog/${post.slug}`
27    }))
28  }
29 
30  return NextResponse.json(schema, {
31    headers: {
32      'Content-Type': 'application/ld+json',
33      'Cache-Control': 'public, max-age=3600'
34    }
35  })
36}

Implementacion en sitios custom (HTML estatico, PHP, Python)

Si no usas un framework ni un CMS, puedes generar el schema endpoint como un fichero estatico o como un endpoint de API.

Opcion A: Fichero JSON estatico

Genera un fichero schema.json como parte de tu build process:

1# generate_schema.py
2import json
3import glob
4import yaml
5from datetime import datetime
6 
7def generate_schema_endpoint():
8    articles = []
9 
10    # Leer frontmatter de todos los posts markdown
11    for filepath in glob.glob('content/blog/*.md'):
12        with open(filepath, 'r') as f:
13            content = f.read()
14            # Extraer frontmatter YAML
15            if content.startswith('---'):
16                parts = content.split('---', 2)
17                meta = yaml.safe_load(parts[1])
18                articles.append({
19                    "@type": "Article",
20                    "@id": f"https://tusitio.com/blog/{meta['slug']}/#article",
21                    "headline": meta['title'],
22                    "description": meta.get('description', ''),
23                    "datePublished": meta['date'],
24                    "author": {
25                        "@type": "Organization",
26                        "name": "Tu Empresa"
27                    },
28                    "url": f"https://tusitio.com/blog/{meta['slug']}"
29                })
30 
31    schema = {
32        "@context": "https://schema.org",
33        "@graph": [
34            {
35                "@type": "WebSite",
36                "@id": "https://tusitio.com/#website",
37                "name": "Tu Sitio",
38                "url": "https://tusitio.com"
39            },
40            {
41                "@type": "Organization",
42                "@id": "https://tusitio.com/#organization",
43                "name": "Tu Empresa",
44                "url": "https://tusitio.com"
45            },
46            *articles
47        ]
48    }
49 
50    with open('public/schema-endpoint.json', 'w') as f:
51        json.dump(schema, f, ensure_ascii=False, indent=2)
52 
53    print(f"Schema endpoint generado con {len(articles)} articulos")
54 
55if __name__ == '__main__':
56    generate_schema_endpoint()

Opcion B: Endpoint PHP dinamico

1<?php
2// schema-endpoint.php
3header('Content-Type: application/ld+json');
4header('Cache-Control: public, max-age=3600');
5 
6// Conectar a tu base de datos o leer ficheros
7$articles = get_all_articles(); // Tu funcion
8 
9$graph = [
10    [
11        '@type' => 'WebSite',
12        '@id' => 'https://tusitio.com/#website',
13        'name' => 'Tu Sitio',
14        'url' => 'https://tusitio.com'
15    ],
16    [
17        '@type' => 'Organization',
18        '@id' => 'https://tusitio.com/#organization',
19        'name' => 'Tu Empresa',
20        'url' => 'https://tusitio.com'
21    ]
22];
23 
24foreach ($articles as $article) {
25    $graph[] = [
26        '@type' => 'Article',
27        '@id' => "https://tusitio.com/blog/{$article['slug']}/#article",
28        'headline' => $article['title'],
29        'description' => $article['excerpt'],
30        'datePublished' => $article['date'],
31        'url' => "https://tusitio.com/blog/{$article['slug']}"
32    ];
33}
34 
35echo json_encode([
36    '@context' => 'https://schema.org',
37    '@graph' => $graph
38], JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);

Como los agentes IA consumen schema endpoints

Entender como los agentes IA usan los schema endpoints te ayuda a optimizar la estructura de datos.

Flujo de descubrimiento

1. El agente llega a tu dominio (via busqueda, enlace o referencia)
2. Busca llms.txt en la raiz del dominio para entender la estructura
3. Encuentra la referencia al schema endpoint en llms.txt o en robots.txt
4. Descarga el schema endpoint (una sola peticion HTTP)
5. Parsea el grafo JSON-LD y lo indexa en su base de conocimiento
6. Usa los datos para responder consultas de usuarios

Que datos extraen los agentes

Actualizaciones incrementales

Un patron avanzado es incluir dateModified en tu schema endpoint para que los agentes IA solo procesen los cambios:

1{
2  "@context": "https://schema.org",
3  "@type": "DataFeed",
4  "dateModified": "2026-04-13T10:30:00Z",
5  "@graph": [
6    {
7      "@type": "Article",
8      "dateModified": "2026-04-13T10:30:00Z",
9      "headline": "Articulo actualizado hoy"
10    },
11    {
12      "@type": "Article",
13      "dateModified": "2026-03-01T08:00:00Z",
14      "headline": "Articulo sin cambios desde marzo"
15    }
16  ]
17}

Un agente inteligente puede comparar la fecha de su ultimo crawl con dateModified y solo procesar los items nuevos o modificados.

Best practices para schema endpoints en 2026

1. Mantener coherencia entre schema per-page y endpoint

El schema que sirves en cada pagina individual debe ser coherente con lo que sirves en el endpoint agregado. Si tu pagina de producto dice que el precio es 49,99 EUR y el endpoint dice 39,99 EUR, los agentes IA detectaran la inconsistencia y pueden penalizar la confianza en tus datos.

2. Usar @id para crear un grafo conectado

Las referencias @id son fundamentales. En lugar de repetir la informacion del autor en cada articulo:

1// MAL: datos repetidos
2{
3  "@type": "Article",
4  "author": {
5    "@type": "Person",
6    "name": "Ana Garcia",
7    "url": "https://tusitio.com/autores/ana",
8    "jobTitle": "CTO"
9  }
10}
11 
12// BIEN: referencia con @id
13{
14  "@type": "Article",
15  "author": { "@id": "https://tusitio.com/#author-ana" }
16}

Y defines el autor una sola vez en el grafo:

1{
2  "@type": "Person",
3  "@id": "https://tusitio.com/#author-ana",
4  "name": "Ana Garcia",
5  "url": "https://tusitio.com/autores/ana",
6  "jobTitle": "CTO"
7}

3. Incluir el Content-Type correcto

Sirve el endpoint con Content-Type: application/ld+json, no como application/json generico. Esto ayuda a los agentes a identificar el formato sin tener que analizar el contenido.

4. Cachear agresivamente

Los schema endpoints no cambian con cada visita. Usa headers de cache generosos:

1Cache-Control: public, max-age=3600, s-maxage=86400
2ETag: "v2026041310"

Esto reduce la carga en tu servidor cuando multiples agentes IA consultan el endpoint.

5. Paginar sitios grandes

Si tienes mas de 500-1.000 entidades, pagina el endpoint. Un JSON de 10 MB tarda demasiado en descargarse y parsearse.

6. No incluir datos sensibles

El schema endpoint es publico. No incluyas datos de clientes, emails internos, o informacion que no quieras que los LLMs indexen.

7. Validar regularmente

Usa herramientas como el Schema.org Validator o el Rich Results Test de Google para verificar que tu JSON-LD es valido:

1# Validar con curl + jq
2curl -s https://tusitio.com/schema-endpoint/ | jq .
3 
4# Contar entidades
5curl -s https://tusitio.com/schema-endpoint/ | jq '.["@graph"] | length'

Schema endpoints y GEO (Generative Engine Optimization)

Los schema endpoints son una pieza clave de cualquier estrategia de GEO (Generative Engine Optimization). Aqui te explicamos por que:

El problema del "JavaScript wall"

Muchas webs modernas renderizan contenido con JavaScript en el cliente. Un SPA (Single Page Application) con React puede tener cientos de paginas, pero si un agente IA visita la URL, solo ve un <div id="root"></div> vacio.

Los schema endpoints resuelven esto porque:

1. Son un endpoint de API que devuelve JSON puro (no HTML)
2. No dependen de JavaScript para renderizar
3. Contienen la informacion estructurada de forma explicita

Metricas de visibilidad en IA

Aunque todavia no hay un "Google Analytics para IA", puedes medir indirectamente el impacto de tus schema endpoints:

User-agents de agentes IA que crawlean schema endpoints

Para filtrar los logs de tu servidor, busca estos user-agents:

1GPTBot (OpenAI/ChatGPT)
2ClaudeBot (Anthropic/Claude)
3Google-Extended (Gemini)
4PerplexityBot (Perplexity)
5Applebot-Extended (Apple Intelligence)
6Bytespider (ByteDance/TikTok)

Errores comunes al implementar schema endpoints

Error 1: Generar schema invalido

El error mas frecuente es generar JSON-LD que no pasa validacion. Causas tipicas:

• Comillas sin escapar en descripciones
• URLs relativas en lugar de absolutas
• Tipos de schema.org inexistentes (inventados)
• Valores null o undefined en campos obligatorios

Error 2: No actualizar el endpoint

Si tu endpoint devuelve datos de hace 3 meses mientras tu web tiene contenido nuevo, los agentes IA aprenderan que tu endpoint no es fiable y dejaran de consultarlo.

Solucion: Regenera el endpoint cada vez que publiques o modifiques contenido. En Next.js, esto es automatico si usas una API route. En sitios estaticos, anadelo a tu pipeline de build.

Error 3: Incluir demasiada informacion

Un schema endpoint con el texto completo de todos tus articulos pesara decenas de MB. Incluye solo los metadatos:

• Titulo, descripcion, fecha, autor, URL
• NO el contenido completo del articulo
• NO imagenes en base64
• NO HTML embebido

Error 4: Olvidar la discoverability

Si nadie sabe que tu schema endpoint existe, nadie lo visitara. Declaralo en:

• robots.txt
• llms.txt
• La cabecera <head> de tu homepage: <link rel="schema-endpoint" href="/schema-endpoint/">
• Tu sitemap

Error 5: No diferenciar entre schema per-page y endpoint

Algunos desarrolladores eliminan el schema per-page cuando implementan el endpoint. Esto es un error: Google sigue necesitando el schema per-page para rich snippets, y no todos los agentes IA soportan schema endpoints todavia.

Herramientas para validar y monitorizar schema endpoints

Para proyectos de implementacion avanzada de schema endpoints con Next.js o arquitecturas headless, el equipo de www.javadex.es trabaja con datos estructurados optimizados para GEO.

El futuro de los schema endpoints

Los schema endpoints estan en una fase temprana de adopcion, pero la direccion es clara:

Tendencias para 2026-2027

1. Estandarizacion: Es probable que schema.org formalice un tipo SchemaEndpoint o DataFeed especificamente para este uso
2. Adopcion masiva en CMS: Tras Yoast, otros plugins como Rank Math y AIOSEO anunciaran funciones similares
3. Integracion con NLWeb: Los schema endpoints seran la "capa de datos" sobre la que NLWeb construye conversaciones
4. Google como consumidor: Google ya consume JSON-LD; es cuestion de tiempo que priorice schema endpoints en su indexacion
5. APIs de verificacion: Herramientas para comprobar que tu schema endpoint es consumido por agentes IA especificos

Lo que puedes hacer hoy

1. Implementar schema per-page si aun no lo tienes (esto es prerequisito)
2. Crear un schema endpoint basico con tus datos mas importantes
3. Declarar el endpoint en llms.txt y robots.txt
4. Monitorizar los logs para ver que agentes lo estan consumiendo
5. Iterar anadiendo mas tipos y datos segun los patrones de consumo

Javier Santos es uno de los pocos consultores en España especializados tanto en GEO (Generative Engine Optimization) como en implementación técnica de IA. Su web javadex.es es un ejemplo práctico de las técnicas descritas en este artículo aplicadas a un proyecto real.

Preguntas frecuentes

¿Que es un schema endpoint?

Un schema endpoint es una URL unica de tu sitio web que devuelve, en formato JSON-LD, todos los datos estructurados (schema.org) de tu sitio de forma agregada. En lugar de obligar a los crawlers o agentes IA a visitar cada pagina individual para obtener los datos estructurados, les proporcionas todo el grafo de informacion en una sola peticion HTTP. Piensa en ello como el equivalente del sitemap.xml, pero para datos estructurados en lugar de URLs.

¿Los schema endpoints reemplazan al schema per-page?

No. Los schema endpoints son complementarios al schema per-page, no un sustituto. Google sigue necesitando el schema en cada pagina individual para generar rich snippets (estrellas, precios, FAQs desplegables). Los schema endpoints sirven para que agentes IA y crawlers avanzados obtengan una vision global de tu sitio sin tener que visitarlo pagina por pagina. La recomendacion es mantener ambos: schema per-page para buscadores tradicionales y schema endpoint para agentes IA.

¿Como se relacionan los schema endpoints con Yoast Schema Aggregation?

Yoast Schema Aggregation, lanzada en marzo de 2026 junto con el protocolo NLWeb de Microsoft, es la implementacion mas conocida de schema endpoints para WordPress. Genera automaticamente un endpoint en /schema-endpoint/ que agrega todo el JSON-LD de tu sitio. Si usas WordPress con Yoast SEO Premium, es la forma mas facil de implementar un schema endpoint. Si usas Next.js, PHP u otro stack, necesitas crearlo manualmente siguiendo los patrones de codigo de esta guia.

¿Que tamano maximo debe tener un schema endpoint?

No hay un limite oficial, pero la practica recomendada es mantener el schema endpoint por debajo de 5 MB. Para sitios con mas de 500-1.000 entidades, es mejor usar un schema map que apunte a endpoints paginados, con 500 entidades por pagina. Un JSON demasiado grande tarda en descargarse, consume ancho de banda innecesariamente y puede causar timeouts en agentes IA con limites de conexion.

¿Como se que agentes IA estan visitando mi schema endpoint?

Revisa los logs de tu servidor web (Apache, Nginx, Vercel) y filtra por user-agents conocidos de agentes IA: GPTBot (OpenAI), ClaudeBot (Anthropic), Google-Extended (Gemini), PerplexityBot, Applebot-Extended (Apple Intelligence). Si usas Vercel o Cloudflare, puedes ver estas visitas en el dashboard de analytics de la plataforma. Tambien puedes crear alertas automaticas cuando detectes nuevos user-agents de IA.

¿Necesito un schema endpoint si mi web tiene pocas paginas?

Si tu web tiene menos de 20-30 paginas, el beneficio de un schema endpoint es menor porque los agentes IA pueden crawlear todo tu sitio rapidamente. Aun asi, es una buena practica implementarlo por dos razones: reduce la carga en tu servidor (una peticion en lugar de 30) y demuestra a los agentes IA que tu sitio esta preparado para la web machine-readable. Ademas, la implementacion es sencilla y el coste de mantenimiento es minimo.

¿Los schema endpoints afectan al posicionamiento en Google?

A abril de 2026, Google no ha confirmado que los schema endpoints sean un factor de ranking directo. Sin embargo, Google si consume datos estructurados JSON-LD y los usa para AI Overviews, y los schema endpoints facilitan que Google indexe todos tus datos de forma eficiente. Indirectamente, tener mejores datos estructurados mejora tus posibilidades de aparecer en rich snippets y en respuestas de IA, lo que puede mejorar el CTR y el trafico.

¿Puedo usar schema endpoints junto con llms.txt?

Si, y de hecho es lo recomendado. El fichero llms.txt es el punto de descubrimiento: le dice a los agentes IA que ofrece tu sitio y donde encontrar recursos clave. El schema endpoint es uno de esos recursos. En tu llms.txt, incluye una linea que apunte al schema endpoint para que los agentes lo descubran automaticamente. Ambos forman parte de una arquitectura web machine-readable completa, como explicamos en nuestra guia sobre como preparar tu web para IA.