Schema Endpoints: Datos Estructurados que la IA Puede Leer de un Vistazo [2026]
Los schema endpoints sirven toda tu estructura de datos en un solo JSON-LD para que agentes IA y buscadores lean tu web sin crawlear cada pagina.
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 : 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:
| Factor | 2024 | 2026 |
|---|---|---|
| Quien lee los datos estructurados | Googlebot, Bingbot | Googlebot, Bingbot, ChatGPT, Claude, Gemini, Perplexity, agentes IA |
| Para que sirven | Rich snippets | Rich snippets + respuestas IA + citaciones + agentes autonomos |
| Donde se leen | En cada pagina individual | En cada pagina + schema endpoints agregados |
| Importancia para trafico | Media (mejora CTR) | Alta (decide si apareces en respuestas IA) |
| Cobertura necesaria | Paginas clave | Todo el sitio |
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 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:
| Concepto | Que es | Analogia |
|---|---|---|
| Schema Endpoint | Una URL que sirve JSON-LD agregado | El sitemap.xml pero para datos estructurados |
| Schema Map | Un indice que apunta a multiples schema endpoints | Un sitemap-index que lista varios sitemaps |
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
dateModifiedpara actualizaciones incrementales - Sigue el estandar schema.org con
@graphpara 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:
| Caracteristica | Schema Endpoints (Yoast) | NLWeb (Microsoft) |
|---|---|---|
| Funcion principal | Servir datos estructurados agregados | Responder queries en lenguaje natural |
| Formato | JSON-LD (schema.org) | JSON basado en schema.org |
| Complejidad de implementacion | Baja (plugin WordPress) | Media-alta (requiere backend) |
| Quien lo consume | Cualquier crawler o agente | Agentes IA compatibles con NLWeb |
| Estado en abril 2026 | Disponible en Yoast Premium | Protocolo abierto, adopcion temprana |
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
| Aspecto | Schema per-page | Schema endpoint |
|---|---|---|
| Alcance | Una pagina | Todo el sitio |
| Peticiones necesarias | 1 por pagina | 1 total |
| Consumo de bandwidth (crawlers) | Alto (N paginas x peso) | Bajo (1 documento) |
| Datos redundantes | Muchos (Organization se repite) | Ninguno (referencias con @id) |
| Utilidad para rich snippets | Esencial | No aplica |
| Utilidad para agentes IA | Parcial (necesitan crawlear) | Total (todo de un vistazo) |
| Mantenimiento | Automatico si usas CMS | Requiere generacion/actualizacion |
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
| Tipo | Para que sirve | Ejemplo de uso |
|---|---|---|
Article / BlogPosting | Contenido editorial | Blog posts, noticias, guias |
FAQPage | Preguntas frecuentes | Secciones FAQ, paginas de soporte |
HowTo | Tutoriales paso a paso | Guias de instalacion, recetas |
Product | Productos con precio | E-commerce, SaaS pricing |
Organization | Informacion de empresa | Datos de contacto, redes sociales |
WebSite | Identidad del sitio | Nombre, URL, buscador interno |
Tier 2: Muy recomendados
| Tipo | Para que sirve | Ejemplo de uso |
|---|---|---|
BreadcrumbList | Navegacion jerarquica | Rutas de paginas |
LocalBusiness | Negocios fisicos | Restaurantes, tiendas, clinicas |
Review / AggregateRating | Valoraciones | Reviews de productos, servicios |
Event | Eventos con fecha | Webinars, conferencias |
Course | Formacion | Cursos online, bootcamps |
SoftwareApplication | Apps y herramientas | SaaS, apps moviles |
Tier 3: Utiles para nichos
| Tipo | Para que sirve |
|---|---|
Recipe | Recetas de cocina |
MedicalCondition | Contenido de salud |
JobPosting | Ofertas de empleo |
RealEstateListing | Inmobiliaria |
FinancialProduct | Seguros, creditos |
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:
- Extraer la respuesta exacta sin interpretar texto libre
- Citar tu web como fuente de la respuesta
- 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
WebSitecon informacion del sitio - El nodo
OrganizationoPerson(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.txt2Sitemap: https://tusitio.com/sitemap.xml3Schema-Endpoint: https://tusitio.com/schema-endpoint/4 5# llms.txt6> Schema endpoint con datos estructurados agregados7Schema: 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.ts2import { 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 // WebSite14 {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 // Organization29 {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.ts2import { 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.ts2import { NextResponse } from 'next/server'3import { getAllPosts } from '@/lib/data'4 5const ITEMS_PER_PAGE = 5006 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_PAGE13 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.py2import json3import glob4import yaml5from datetime import datetime6 7def generate_schema_endpoint():8 articles = []9 10 # Leer frontmatter de todos los posts markdown11 for filepath in glob.glob('content/blog/*.md'):12 with open(filepath, 'r') as f:13 content = f.read()14 # Extraer frontmatter YAML15 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 *articles47 ]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<?php2// schema-endpoint.php3header('Content-Type: application/ld+json');4header('Cache-Control: public, max-age=3600');5 6// Conectar a tu base de datos o leer ficheros7$articles = get_all_articles(); // Tu funcion8 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' => $graph38], 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
- El agente llega a tu dominio (via busqueda, enlace o referencia)
- Busca
llms.txten la raiz del dominio para entender la estructura - Encuentra la referencia al schema endpoint en
llms.txto enrobots.txt - Descarga el schema endpoint (una sola peticion HTTP)
- Parsea el grafo JSON-LD y lo indexa en su base de conocimiento
- Usa los datos para responder consultas de usuarios
Que datos extraen los agentes
| Tipo de dato | Como lo usa el agente | Ejemplo de consulta que responde |
|---|---|---|
Article.headline + description | Citar tu contenido | "Que dice Upliora sobre schema endpoints" |
Product.name + offers.price | Comparar productos | "Cuanto cuesta la herramienta X" |
FAQPage.mainEntity | Responder preguntas directas | "Como implementar datos estructurados" |
Organization.sameAs | Verificar autoridad | "Quien esta detras de esta web" |
HowTo.step | Dar instrucciones | "Como instalar schema endpoint en Next.js" |
Review.reviewRating | Evaluar calidad | "Que opinion tienen los usuarios de X" |
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 repetidos2{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 @id13{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=864002ETag: "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 + jq2curl -s https://tusitio.com/schema-endpoint/ | jq .3 4# Contar entidades5curl -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 vacio.
Los schema endpoints resuelven esto porque:
- Son un endpoint de API que devuelve JSON puro (no HTML)
- No dependen de JavaScript para renderizar
- 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:
| Metrica | Como medirla |
|---|---|
| Crawl rate del endpoint | Logs del servidor (busca user-agents de IA) |
| Citaciones en ChatGPT | Buscar tu dominio en respuestas de ChatGPT |
| AI Overviews en Google | Google Search Console > Search Appearance > AIO_CITATION |
| Trafico desde Perplexity | Google Analytics > Fuentes de trafico |
| Apariciones en Copilot | Bing Webmaster Tools (cuando habiliten el endpoint) |
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.txtllms.txt- La cabecera
de tu homepage: - 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
| Herramienta | Funcion | Precio |
|---|---|---|
| Schema.org Validator | Validar JSON-LD | Gratis |
| Google Rich Results Test | Probar rich results | Gratis |
| Yoast SEO Premium | Generar y gestionar schema | 99 EUR/ano |
| Schema App | Plataforma enterprise de schema | Desde 499 USD/mes |
| Merkle Schema Markup Generator | Generar schema manualmente | Gratis |
| Screaming Frog | Auditar schema de todo el sitio | 259 GBP/ano |
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
- Estandarizacion: Es probable que schema.org formalice un tipo
SchemaEndpointoDataFeedespecificamente para este uso - Adopcion masiva en CMS: Tras Yoast, otros plugins como Rank Math y AIOSEO anunciaran funciones similares
- Integracion con NLWeb: Los schema endpoints seran la "capa de datos" sobre la que NLWeb construye conversaciones
- Google como consumidor: Google ya consume JSON-LD; es cuestion de tiempo que priorice schema endpoints en su indexacion
- APIs de verificacion: Herramientas para comprobar que tu schema endpoint es consumido por agentes IA especificos
Lo que puedes hacer hoy
- Implementar schema per-page si aun no lo tienes (esto es prerequisito)
- Crear un schema endpoint basico con tus datos mas importantes
- Declarar el endpoint en llms.txt y robots.txt
- Monitorizar los logs para ver que agentes lo estan consumiendo
- Iterar anadiendo mas tipos y datos segun los patrones de consumo
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.
¿Listo para poner tu proyecto en producción?
Si estás siguiendo este tutorial, necesitas un servidor donde desplegarlo. Yo uso Hostinger para mis proyectos porque el panel es intuitivo, los VPS van con SSD NVMe, y a 4,99€/mes no hay nada comparable en relación calidad-precio.
* Enlace de afiliado. Si contratas a través de este enlace, nos ayudas a mantener este contenido gratuito.
Posts Relacionados
Consultoría IA en San Sebastián (Donostia): Agentes, Automatización y Modelos Privados para Empresas [2026]
Guía completa de servicios de inteligencia artificial en San Sebastián: agentes IA, automatización, modelos privados y consultoría para empresas vascas en 2026.
Kit Digital 2026 para IA: Cómo Solicitar Hasta 12.000€ para tu PYME Paso a Paso
Tutorial paso a paso para solicitar el Kit Digital 2026 con soluciones de IA. Requisitos, cuantías por segmento (hasta 12.000€), agentes digitalizadores y errores que rechazan tu solicitud.
Formación en Claude Code para Empresas en España: Proveedores, Precios y Qué Esperar [2026]
Guía de formación en Claude Code para empresas españolas: proveedores, precios (desde 4.000€), programas in-company, duración y resultados esperados.
Javier Santos Criado
Consultor de IA y Automatización | Fundador de Javadex
Experto en implementación de soluciones de Inteligencia Artificial para empresas. Especializado en automatización con n8n, integración de LLMs, y desarrollo de agentes IA.
Lleva tu proyecto a producción
Hosting web desde 2,99€/mes o VPS con SSD NVMe desde 4,99€/mes. Panel intuitivo, IP dedicada y soporte 24/7 en español.
¿Quieres más contenido de IA?
Explora nuestras comparativas y guías