NLWeb de Microsoft: El Protocolo que Conecta tu Web con la IA [2026]

TLDR: NLWeb es un protocolo abierto de Microsoft que permite a los agentes de IA consultar tu sitio web de forma conversacional, como si hablasen directamente con tu contenido. Se basa en schema.org (que los LLMs ya entienden), se declara con una sola etiqueta en el HTML, y expone un endpoint donde los agentes envian preguntas en lenguaje natural y reciben respuestas estructuradas. Junto con llms.txt y Content Negotiation, NLWeb forma la tercera capa de la web legible por maquinas que esta redefiniendo la relacion entre sitios web e inteligencia artificial.

Que es NLWeb y por que deberia importarte

NLWeb (Natural Language Web) es un protocolo abierto publicado por Microsoft en GitHub que permite a cualquier sitio web exponer un endpoint conversacional para agentes de IA. En lugar de que un crawler extraiga tu HTML, parsee tus encabezados y adivine el contexto, NLWeb invierte la dinamica: tu sitio responde directamente a preguntas en lenguaje natural.

El concepto no es nuevo en teoria. Las APIs REST llevan decadas haciendo algo parecido para aplicaciones. Pero NLWeb esta disenado especificamente para LLMs y agentes de IA, con tres decisiones de diseno que lo hacen diferente:

1. Construido sobre schema.org: No inventa un vocabulario nuevo. Usa los tipos y propiedades de schema.org que Google, Bing y millones de webs ya utilizan. Los LLMs ya entienden schema.org porque esta en sus datos de entrenamiento.

1. Descubrimiento mediante : Los agentes encuentran tu endpoint NLWeb de la misma forma que encuentran tu RSS feed o tu sitemap: a traves de una etiqueta en el de tu HTML.

1. Interfaz conversacional, no de busqueda: El agente no envia keywords. Envia una pregunta en lenguaje natural ("que producto teneis para equipos de menos de 10 personas con presupuesto limitado") y recibe una respuesta estructurada con los datos relevantes de tu sitio.

Microsoft publico la especificacion en su repositorio de GitHub (microsoft/NLWeb) en mayo de 2025, y desde entonces el ecosistema ha ido creciendo con implementaciones para WordPress (via Yoast), Next.js, Django y servidores estaticos.

El problema que resuelve NLWeb

Hoy, cuando un agente de IA como ChatGPT, Claude o Perplexity quiere obtener informacion de tu web, tiene que:

1. Hacer una peticion HTTP a tu URL
2. Recibir el HTML completo (navegacion, scripts, CSS, contenido, footer...)
3. Parsear ese HTML para extraer el contenido relevante
4. Interpretar el contexto a partir de encabezados, listas y parrafos

Este proceso es lento, costoso en tokens y propenso a errores. El agente no sabe si tu web vende zapatos o servicios de consultoria hasta que analiza el contenido.

Con NLWeb, el flujo cambia a:

1. El agente lee en tu HTML
2. Envia una peticion POST a /nlweb con la pregunta: "cual es vuestro plan mas barato para equipos pequenos"
3. Recibe una respuesta JSON-LD con schema.org: tipo Product, precio, descripcion, URL de compra

El ahorro es brutal: de miles de tokens parseando HTML a decenas de tokens con informacion precisa y estructurada.

Como funciona NLWeb: Arquitectura tecnica

La arquitectura de NLWeb tiene tres componentes principales que trabajan juntos.

1. El tag de descubrimiento

En el de tu HTML, anades una etiqueta link que informa a los agentes de que tu sitio soporta NLWeb:

1<link rel="nlweb" href="https://tusitio.com/nlweb" type="application/nlweb+json" />

Esta etiqueta funciona exactamente como o . Los agentes que soporten NLWeb la detectan automaticamente al visitar cualquier pagina de tu sitio.

Tambien puedes declararlo en tu robots.txt:

1NLWeb: https://tusitio.com/nlweb

O en el archivo /.well-known/nlweb.json:

1{
2  "endpoint": "https://tusitio.com/nlweb",
3  "version": "1.0",
4  "schema_types": ["Product", "Article", "FAQPage", "Organization"]
5}

2. El endpoint conversacional

El nucleo de NLWeb es un endpoint HTTP que acepta peticiones POST con preguntas en lenguaje natural y responde con datos estructurados en JSON-LD usando vocabulario de schema.org.

Una peticion tipica:

1{
2  "query": "que herramientas de IA ofreceis para automatizar atencion al cliente",
3  "context": {
4    "agent": "Claude/4.6",
5    "language": "es",
6    "max_results": 5
7  }
8}

Y la respuesta:

1{
2  "@context": "https://schema.org",
3  "@type": "SearchResultsPage",
4  "query": "herramientas de IA para automatizar atencion al cliente",
5  "mainEntity": [
6    {
7      "@type": "SoftwareApplication",
8      "name": "ChatBot IA Premium",
9      "description": "Chatbot con IA generativa para atencion al cliente 24/7",
10      "url": "https://tusitio.com/productos/chatbot-premium",
11      "offers": {
12        "@type": "Offer",
13        "price": "49.99",
14        "priceCurrency": "EUR"
15      },
16      "applicationCategory": "CustomerService"
17    }
18  ],
19  "totalResults": 3,
20  "responseConfidence": 0.92
21}

La clave esta en que el endpoint no necesita ser un LLM. Puede ser una busqueda semantica contra tu base de datos, una consulta a tu CMS con filtros, o incluso un simple full-text search con ranking. El protocolo no prescribe como generas la respuesta, solo el formato de entrada y salida.

3. La capa de schema.org

NLWeb no inventa nuevos tipos de datos. Reutiliza el vocabulario de schema.org que ya existe y que la mayoria de webs ya implementan para SEO:

NLWeb y Yoast: Schema Aggregation en WordPress

Uno de los desarrollos mas significativos para NLWeb llego en marzo de 2026, cuando Yoast lanzo Schema Aggregation, una funcionalidad que convierte automaticamente el schema.org de cualquier sitio WordPress en un endpoint NLWeb compatible.

Que es Schema Aggregation de Yoast

Yoast lleva anos generando JSON-LD de schema.org para sitios WordPress. Schema Aggregation va un paso mas alla: agrega todo el schema.org de todas tus paginas en un indice centralizado y lo expone como endpoint NLWeb.

En la practica, si tienes un blog WordPress con 200 articulos y cada uno tiene schema.org de tipo Article, Yoast Schema Aggregation:

1. Recopila el schema.org de los 200 articulos
2. Indexa los datos en una estructura de busqueda local
3. Expone el endpoint /nlweb que acepta preguntas en lenguaje natural
4. Responde con los articulos relevantes en formato JSON-LD

La colaboracion Microsoft-Yoast

La historia detras de esta integracion es relevante. Joost de Valk (fundador de Yoast) y el equipo de NLWeb de Microsoft llevaban meses trabajando en paralelo en el mismo problema: como hacer que los sitios web sean consultables por agentes de IA.

Microsoft tenia el protocolo (NLWeb). Yoast tenia la distribucion (35+ millones de sitios WordPress). La colaboracion era natural.

El resultado es que cualquier sitio WordPress con Yoast SEO Premium puede activar NLWeb con un click desde el panel de Yoast. No necesita codigo, no necesita configuracion de servidor, no necesita saber que es un endpoint REST.

Configuracion en WordPress con Yoast

Para activar NLWeb en tu sitio WordPress con Yoast SEO Premium (version 24.0+):

1. Ve a Yoast SEO > Ajustes > Avanzado
2. Busca la seccion "AI & Schema Aggregation"
3. Activa "Habilitar endpoint NLWeb"
4. Opcionalmente, configura que tipos de contenido incluir (entradas, paginas, productos WooCommerce...)
5. Guarda los cambios

Yoast genera automaticamente:

• El endpoint en tusitio.com/nlweb
• La etiqueta en todas las paginas
• La entrada en /.well-known/nlweb.json
• La declaracion en robots.txt

Para sitios WordPress sin Yoast Premium, Joost de Valk tambien publico un plugin independiente de NLWeb (gratuito) que hace lo mismo pero con configuracion manual.

Implementar NLWeb en Next.js y sitios modernos

Si tu sitio no usa WordPress, implementar NLWeb es un proyecto de fin de semana. Veamos como hacerlo en Next.js, que es el framework que usamos en Upliora y que muchos desarrolladores eligen para sitios modernos.

Paso 1: Anadir el tag de descubrimiento

En tu layout.tsx o _document.tsx:

1// app/layout.tsx (Next.js App Router)
2export default function RootLayout({ children }) {
3  return (
4    <html lang="es">
5      <head>
6        <link
7          rel="nlweb"
8          href="https://tusitio.com/api/nlweb"
9          type="application/nlweb+json"
10        />
11      </head>
12      <body>{children}</body>
13    </html>
14  )
15}

Paso 2: Crear el endpoint API

1// app/api/nlweb/route.ts
2import { NextRequest, NextResponse } from 'next/server'
3 
4// Tu funcion de busqueda semantica o full-text
5import { searchContent } from '@/lib/search'
6import { getSchemaForResult } from '@/lib/schema'
7 
8export async function POST(request: NextRequest) {
9  const { query, context } = await request.json()
10 
11  // Validar la peticion
12  if (!query || typeof query !== 'string') {
13    return NextResponse.json(
14      { error: 'Se requiere un campo "query" con la pregunta' },
15      { status: 400 }
16    )
17  }
18 
19  // Buscar contenido relevante
20  const results = await searchContent(query, {
21    language: context?.language || 'es',
22    maxResults: context?.max_results || 10,
23  })
24 
25  // Formatear como JSON-LD con schema.org
26  const response = {
27    '@context': 'https://schema.org',
28    '@type': 'SearchResultsPage',
29    query: query,
30    mainEntity: results.map(result => getSchemaForResult(result)),
31    totalResults: results.length,
32    responseConfidence: results[0]?.score || 0,
33  }
34 
35  return NextResponse.json(response, {
36    headers: {
37      'Content-Type': 'application/nlweb+json',
38      'Access-Control-Allow-Origin': '*',
39    },
40  })
41}
42 
43// Manejar peticiones OPTIONS para CORS
44export async function OPTIONS() {
45  return NextResponse.json({}, {
46    headers: {
47      'Access-Control-Allow-Origin': '*',
48      'Access-Control-Allow-Methods': 'POST, OPTIONS',
49      'Access-Control-Allow-Headers': 'Content-Type',
50    },
51  })
52}

Paso 3: La funcion de busqueda

El endpoint NLWeb necesita una forma de buscar tu contenido. Tienes varias opciones segun tu complejidad:

Opcion simple: busqueda por keywords

1// lib/search.ts
2import posts from '@/data/blog-posts.json'
3 
4export async function searchContent(query: string, options: any) {
5  const keywords = query.toLowerCase().split(' ')
6 
7  return posts
8    .filter(post => {
9      const text = `${post.title} ${post.excerpt} ${post.keywords?.join(' ')}`.toLowerCase()
10      return keywords.some(kw => text.includes(kw))
11    })
12    .slice(0, options.maxResults)
13    .map((post, i) => ({
14      ...post,
15      score: 1 - (i * 0.1),
16      type: 'Article'
17    }))
18}

Opcion avanzada: embeddings con vector search

1// lib/search.ts
2import { OpenAI } from 'openai'
3 
4const openai = new OpenAI()
5 
6export async function searchContent(query: string, options: any) {
7  // Generar embedding de la query
8  const embedding = await openai.embeddings.create({
9    model: 'text-embedding-3-small',
10    input: query,
11  })
12 
13  // Buscar en tu vector database (Pinecone, Qdrant, etc.)
14  const results = await vectorDB.query({
15    vector: embedding.data[0].embedding,
16    topK: options.maxResults,
17    filter: { language: options.language },
18  })
19 
20  return results.matches.map(match => ({
21    ...match.metadata,
22    score: match.score,
23  }))
24}

Paso 4: Generar schema.org para cada resultado

1// lib/schema.ts
2export function getSchemaForResult(result: any) {
3  switch (result.type) {
4    case 'Article':
5      return {
6        '@type': 'Article',
7        headline: result.title,
8        description: result.excerpt,
9        url: `https://tusitio.com/blog/${result.slug}`,
10        datePublished: result.date,
11        author: {
12          '@type': 'Person',
13          name: result.author,
14        },
15        keywords: result.keywords?.join(', '),
16      }
17    case 'Product':
18      return {
19        '@type': 'Product',
20        name: result.title,
21        description: result.description,
22        url: result.url,
23        offers: {
24          '@type': 'Offer',
25          price: result.price,
26          priceCurrency: 'EUR',
27        },
28      }
29    default:
30      return {
31        '@type': 'WebPage',
32        name: result.title,
33        description: result.excerpt,
34        url: result.url,
35      }
36  }
37}

Si quieres ver una implementacion real de NLWeb en produccion con Next.js, el portfolio de Javier Santos en Javadex es un ejemplo de sitio que ya aplica las mejores practicas de web legible por maquinas, incluyendo schema.org avanzado y endpoints optimizados para agentes de IA.

NLWeb vs llms.txt vs Content Negotiation: capas complementarias

Este es el punto que mas confusion genera: NLWeb, llms.txt y Content Negotiation no compiten entre si. Son capas complementarias de la web legible por maquinas.

Cada una resuelve un problema diferente:

llms.txt: el indice para LLMs

llms.txt es un archivo en la raiz de tu dominio (como robots.txt) que lista tu contenido en formato legible por LLMs. Es una propuesta de Jeremy Howard que ha ganado traccion rapida.

1# Mi Sitio Web
2 
3## Documentacion
4- [Guia de inicio](/docs/getting-started): Como empezar con nuestro producto
5- [API Reference](/docs/api): Documentacion completa de la API
6- [FAQ](/faq): Preguntas frecuentes
7 
8## Blog
9- [Como usar IA en tu negocio](/blog/ia-negocio): Guia practica para pymes

Si quieres profundizar en Content Negotiation y como servir markdown a agentes de IA, tenemos una guia dedicada sobre markdown para agentes de IA y Content Negotiation que cubre la implementacion completa.

Content Negotiation: el formato adecuado

Content Negotiation permite que tu servidor sirva HTML a navegadores y markdown a agentes de IA, usando el header HTTP Accept. Es lo que Cloudflare lanzo como "Markdown for Agents" en febrero de 2026.

NLWeb: la consulta directa

NLWeb va mas alla de servir contenido: permite una interaccion conversacional. El agente no pide "dame la pagina X", sino "responde esta pregunta usando la informacion de tu sitio".

Como funcionan juntas las tres capas

El flujo completo de un agente de IA interactuando con tu sitio seria:

1. Descubrimiento (llms.txt): El agente visita tusitio.com/llms.txt y obtiene un mapa del contenido disponible.

1. Formato optimizado (Content Negotiation): Si necesita leer una pagina concreta, envia Accept: text/markdown y recibe markdown limpio en vez de HTML (80% menos tokens).

1. Consulta directa (NLWeb): Si necesita una respuesta especifica, detecta y envia una pregunta en lenguaje natural al endpoint. Recibe datos estructurados.

Implementar las tres no es redundante, es progresivo. Cada capa cubre un caso de uso diferente, y un sitio que las tenga todas sera exponencialmente mas util para agentes de IA que uno que solo tenga HTML plano.

Casos de uso practicos de NLWeb

NLWeb tiene aplicaciones claras en varios tipos de sitio. Veamos los mas evidentes.

E-commerce: consultas de producto

Un agente de IA haciendo compras por un usuario podria enviar:

1{
2  "query": "zapatillas de running para mujer talla 38 por menos de 80 euros",
3  "context": { "agent": "ChatGPT-Shopping/1.0", "language": "es" }
4}

Y recibir directamente los productos que encajan, con precio, disponibilidad y URL de compra. Sin parsear HTML, sin navegar categorias, sin filtrar resultados.

Documentacion tecnica: respuestas exactas

Para una web de documentacion tecnica:

1{
2  "query": "como configurar autenticacion OAuth2 con el SDK de Python",
3  "context": { "agent": "Claude-Code/4.6", "max_results": 3 }
4}

La respuesta incluiria el articulo exacto de la documentacion con los snippets de codigo relevantes.

Blogs y medios: busqueda semantica

Para un blog como el que estas leyendo:

1{
2  "query": "comparativa de herramientas de IA para automatizar atencion al cliente en espana",
3  "context": { "language": "es", "max_results": 5 }
4}

El endpoint devolveria los articulos mas relevantes con sus extractos, fechas y URLs.

Si tienes un ecommerce o un SaaS, implementar NLWeb te posiciona para que los agentes de IA que ya estan empezando a comprar por los usuarios puedan interactuar con tu catalogo directamente.

Negocios locales: informacion operativa

Un restaurante con NLWeb podria responder a:

1{
2  "query": "teneis opciones veganas y aceptais reservas para 8 personas el sabado"
3}

Con una respuesta que incluya el menu, horarios, capacidad y enlace de reserva.

Implementacion avanzada: autenticacion, rate limiting y cache

Para un despliegue en produccion, el endpoint NLWeb basico necesita tres capas adicionales.

Rate limiting

Los agentes de IA pueden hacer muchas peticiones. Protege tu endpoint:

1// middleware.ts (Next.js)
2import { NextResponse } from 'next/server'
3import type { NextRequest } from 'next/server'
4 
5const rateLimit = new Map<string, { count: number; resetTime: number }>()
6 
7export function middleware(request: NextRequest) {
8  if (!request.nextUrl.pathname.startsWith('/api/nlweb')) {
9    return NextResponse.next()
10  }
11 
12  const ip = request.headers.get('x-forwarded-for') || 'unknown'
13  const now = Date.now()
14  const limit = rateLimit.get(ip)
15 
16  if (limit && now < limit.resetTime) {
17    if (limit.count >= 60) { // 60 peticiones por minuto
18      return NextResponse.json(
19        { error: 'Rate limit exceeded' },
20        { status: 429 }
21      )
22    }
23    limit.count++
24  } else {
25    rateLimit.set(ip, { count: 1, resetTime: now + 60000 })
26  }
27 
28  return NextResponse.next()
29}

Cache de respuestas

Las preguntas frecuentes se repiten. Cachea las respuestas:

1// lib/nlweb-cache.ts
2const cache = new Map<string, { data: any; expiry: number }>()
3const CACHE_TTL = 3600000 // 1 hora
4 
5export function getCachedResponse(query: string) {
6  const normalized = query.toLowerCase().trim()
7  const cached = cache.get(normalized)
8 
9  if (cached && Date.now() < cached.expiry) {
10    return cached.data
11  }
12 
13  return null
14}
15 
16export function setCachedResponse(query: string, data: any) {
17  const normalized = query.toLowerCase().trim()
18  cache.set(normalized, {
19    data,
20    expiry: Date.now() + CACHE_TTL,
21  })
22}

Autenticacion opcional

Si quieres controlar que agentes pueden consultar tu endpoint:

1// Verificar API key de agentes registrados
2const agentKey = request.headers.get('X-NLWeb-Key')
3 
4if (agentKey) {
5  const isValid = await verifyAgentKey(agentKey)
6  if (!isValid) {
7    return NextResponse.json(
8      { error: 'Invalid agent key' },
9      { status: 401 }
10    )
11  }
12}
13 
14// Sin key: resultados publicos limitados
15// Con key: resultados completos

NLWeb para SEO y GEO: implicaciones estrategicas

NLWeb no es solo una curiosidad tecnica. Tiene implicaciones profundas para como los sitios web seran descubiertos y recomendados en la era de los agentes de IA.

De SEO a AEO (Agent Engine Optimization)

El SEO tradicional optimiza tu sitio para crawlers de busqueda que leen HTML y siguen enlaces. NLWeb optimiza tu sitio para agentes de IA que hacen preguntas y esperan respuestas.

La diferencia es fundamental:

• SEO: Optimizas para que Google indexe tu pagina y la muestre en resultados
• GEO: Optimizas para que ChatGPT y Perplexity citen tu contenido en respuestas
• AEO con NLWeb: Optimizas para que agentes de IA consulten tu sitio directamente cuando un usuario les pide algo

Es la evolucion natural. Si te interesa el GEO (Generative Engine Optimization), puedes complementar esta guia con nuestra guia de ChatGPT para SEO que cubre como los motores de IA estan cambiando la busqueda.

Ventaja competitiva temprana

En abril de 2026, muy pocos sitios web tienen NLWeb implementado. Esto significa que los agentes de IA que ya soportan NLWeb (y cada vez son mas) tienen pocas fuentes a las que consultar directamente. Ser de los primeros en tu nicho te da una ventaja desproporcionada.

Es similar a lo que paso con schema.org en 2012: los que lo implementaron temprano dominaron los rich snippets de Google durante anos.

NLWeb y el futuro de los enlaces

Una implicacion interesante: si un agente puede consultar tu sitio directamente via NLWeb, tiene mas razones para citar tu URL como fuente. No necesita encontrarte en un buscador; ya sabe que tu sitio tiene la respuesta porque te la ha preguntado directamente.

Esto podria crear un ciclo virtuoso:

1. Agente consulta tu NLWeb
2. Recibe respuesta precisa
3. Cita tu URL al usuario
4. El usuario visita tu web
5. El agente aprende que tu sitio es fiable y lo consulta mas

Implementar NLWeb en otros frameworks

Aunque hemos visto Next.js en detalle, NLWeb se puede implementar en cualquier stack.

Django / Python

1# views.py
2from django.http import JsonResponse
3from django.views.decorators.csrf import csrf_exempt
4import json
5 
6@csrf_exempt
7def nlweb_endpoint(request):
8    if request.method != 'POST':
9        return JsonResponse({'error': 'Method not allowed'}, status=405)
10 
11    body = json.loads(request.body)
12    query = body.get('query', '')
13 
14    # Buscar en tu contenido
15    from .search import semantic_search
16    results = semantic_search(query, max_results=10)
17 
18    response = {
19        '@context': 'https://schema.org',
20        '@type': 'SearchResultsPage',
21        'query': query,
22        'mainEntity': [r.to_schema() for r in results],
23        'totalResults': len(results),
24    }
25 
26    return JsonResponse(response, content_type='application/nlweb+json')

Express.js / Node.js

1// routes/nlweb.js
2const express = require('express')
3const router = express.Router()
4 
5router.post('/nlweb', async (req, res) => {
6  const { query, context } = req.body
7 
8  if (!query) {
9    return res.status(400).json({ error: 'Query required' })
10  }
11 
12  const results = await searchContent(query, context)
13 
14  res.setHeader('Content-Type', 'application/nlweb+json')
15  res.json({
16    '@context': 'https://schema.org',
17    '@type': 'SearchResultsPage',
18    query,
19    mainEntity: results.map(formatAsSchema),
20    totalResults: results.length,
21  })
22})
23 
24module.exports = router

Sitio estatico con Cloudflare Workers

Incluso un sitio estatico puede tener NLWeb usando un Worker de Cloudflare:

1// worker.js
2export default {
3  async fetch(request, env) {
4    const url = new URL(request.url)
5 
6    if (url.pathname === '/nlweb' && request.method === 'POST') {
7      const { query } = await request.json()
8 
9      // Buscar en un KV store con tu contenido indexado
10      const index = await env.CONTENT_INDEX.get('index', 'json')
11      const results = searchIndex(index, query)
12 
13      return new Response(JSON.stringify({
14        '@context': 'https://schema.org',
15        '@type': 'SearchResultsPage',
16        query,
17        mainEntity: results,
18      }), {
19        headers: { 'Content-Type': 'application/nlweb+json' },
20      })
21    }
22 
23    return fetch(request) // Pasar al origen para todo lo demas
24  }
25}

Testing y validacion de tu endpoint NLWeb

Una vez implementado, necesitas verificar que funciona correctamente.

Test manual con curl

1# Test basico
2curl -X POST https://tusitio.com/api/nlweb \
3  -H "Content-Type: application/json" \
4  -d '{"query": "que servicios ofreceis para pymes"}'
5 
6# Test con contexto
7curl -X POST https://tusitio.com/api/nlweb \
8  -H "Content-Type: application/json" \
9  -d '{
10    "query": "precio del plan basico",
11    "context": {
12      "agent": "test-agent/1.0",
13      "language": "es",
14      "max_results": 3
15    }
16  }'

Verificar el tag de descubrimiento

1# Comprobar que el link tag esta presente
2curl -s https://tusitio.com | grep 'rel="nlweb"'
3 
4# Comprobar el .well-known
5curl -s https://tusitio.com/.well-known/nlweb.json | python -m json.tool

Validar el formato de respuesta

Comprueba que tu respuesta cumple con la especificacion:

• El campo @context es https://schema.org
• El campo @type es SearchResultsPage
• mainEntity es un array de objetos con tipos validos de schema.org
• Cada entidad tiene al menos @type, name y url
• El JSON es valido y parseable

Herramienta de validacion de Microsoft

Microsoft proporciona una herramienta de validacion en el repositorio de NLWeb:

1# Clonar el repo de NLWeb
2git clone https://github.com/microsoft/NLWeb.git
3 
4# Ejecutar el validador
5cd NLWeb/tools
6python validate_endpoint.py --url https://tusitio.com/api/nlweb --query "test query"

Estado actual del ecosistema NLWeb (abril 2026)

El ecosistema NLWeb esta en una fase temprana pero con traccion real.

Agentes que soportan NLWeb

CMSs con soporte nativo

Adopcion por sectores

Los sectores donde NLWeb esta ganando mas traccion son:

1. E-commerce (consultas de producto por agentes de compra)
2. Documentacion tecnica (Claude Code y Copilot buscando APIs)
3. Medios de comunicacion (Perplexity buscando fuentes)
4. SaaS (agentes evaluando herramientas para usuarios)
5. Restauracion y hosteleria (agentes reservando para usuarios)

Mejores practicas para NLWeb

Despues de analizar las primeras implementaciones en produccion, estas son las practicas que mejor funcionan.

1. Respuestas concisas pero completas

No devuelvas parrafos enteros de tus articulos. Devuelve datos estructurados con los campos esenciales. El agente puede seguir la URL si necesita mas detalle.

2. Incluye siempre la URL canonica

Cada resultado debe tener una URL que el agente pueda compartir con el usuario. Sin URL, el agente no puede citar tu fuente.

3. Usa los tipos de schema.org mas especificos

En vez de WebPage generico, usa Article, Product, HowTo, FAQPage, etc. Cuanto mas especifico, mas util para el agente.

4. Mantiene el indice actualizado

Si anadiste un producto o articulo nuevo, tu endpoint NLWeb deberia reflejarlo inmediatamente. Configura webhooks o regeneracion automatica cuando cambies contenido.

5. Monitoriza las consultas

Registra que preguntan los agentes a tu endpoint. Esto te da insights invaluables sobre que buscan los usuarios a traves de IA, y puedes crear contenido que responda a esas preguntas.

6. Implementa las tres capas

NLWeb funciona mejor cuando va acompanado de llms.txt (para descubrimiento) y Content Negotiation (para lectura de paginas individuales). Las tres capas juntas cubren todos los casos de uso de los agentes de IA.

Preguntas frecuentes sobre NLWeb

¿NLWeb es un estandar oficial o una propuesta de Microsoft?

NLWeb es un protocolo abierto publicado por Microsoft bajo licencia MIT en GitHub. No es un estandar del W3C ni de IETF (aun), pero al estar basado en schema.org (que si es un estandar) y tener el respaldo de Microsoft y Yoast, tiene una base solida para convertirse en estandar de facto. El repositorio acepta contribuciones de la comunidad y tiene una especificacion documentada.

¿Necesito un LLM propio para implementar NLWeb?

No. El endpoint NLWeb no necesita IA para funcionar. Puede usar busqueda por keywords, busqueda full-text (como Elasticsearch o MeiliSearch), o incluso filtros simples sobre una base de datos. Lo que importa es que la respuesta este en formato JSON-LD con schema.org. Usar embeddings y busqueda semantica mejora la calidad de las respuestas, pero no es requisito.

¿NLWeb sustituye al SEO tradicional?

No, lo complementa. El SEO tradicional sigue siendo esencial para que Google indexe tu sitio. NLWeb anade una capa para agentes de IA que va por encima del SEO. Piensa en ello como tener un sitemap (para Google) y un endpoint NLWeb (para agentes). Los dos coexisten y sirven a audiencias diferentes. A medio plazo, es probable que Google tambien integre consultas NLWeb en su crawler.

¿Cuantos tokens consume una consulta NLWeb frente a parsear HTML?

Depende de la pagina, pero las mediciones tipicas muestran: una pagina HTML media tiene entre 3.000 y 15.000 tokens. La respuesta NLWeb equivalente tiene entre 100 y 500 tokens. Es una reduccion del 90-97% en uso de tokens, lo que se traduce en menor coste, mayor velocidad y mejor precision para el agente.

¿NLWeb funciona con sitios estaticos?

Si. Puedes implementar NLWeb en sitios estaticos usando Cloudflare Workers, Vercel Edge Functions, o cualquier servicio serverless que pueda procesar peticiones POST. El contenido se pre-indexa en un KV store o en un JSON estatico, y el Worker se encarga de buscar y responder. No necesitas un servidor persistente.

¿Como saber si agentes de IA estan usando mi endpoint NLWeb?

Monitoriza los logs de tu endpoint buscando User-Agents que contengan "GPT", "Claude", "Perplexity", "Copilot" o "Bot". Tambien puedes implementar un header custom (X-NLWeb-Agent) que los agentes bien configurados envian. Microsoft recomienda registrar las queries para analisis (respetando GDPR).

¿NLWeb compite con el protocolo MCP de Anthropic?

No directamente. MCP (Model Context Protocol) es un protocolo para conectar LLMs con herramientas y fuentes de datos de forma bidireccional. NLWeb es un protocolo para que sitios web expongan su contenido a agentes de IA. Son complementarios: un agente podria usar MCP para conectarse con herramientas internas y NLWeb para consultar sitios web externos.

¿Hay riesgos de seguridad con NLWeb?

Los mismos que con cualquier endpoint publico: rate limiting, validacion de inputs, y no exponer informacion sensible. NLWeb deberia servir solo la misma informacion que ya es publica en tu web. Nunca expongas datos privados, precios internos o informacion de clientes a traves del endpoint. Implementa rate limiting (60-100 peticiones/minuto) y valida que la query no contenga inyecciones.

Conclusion: NLWeb es la API que toda web necesitara

NLWeb resuelve un problema real: los agentes de IA necesitan una forma eficiente de consultar sitios web, y el HTML no fue disenado para eso. Al construir sobre schema.org, NLWeb evita reinventar la rueda y aprovecha una infraestructura que millones de webs ya tienen.

La integracion con Yoast baja la barrera de entrada drasticamente para WordPress (el 43% de la web). Para sitios modernos con Next.js o similares, la implementacion es un endpoint API y un tag en el HTML.

Si estas construyendo o manteniendo un sitio web en 2026, anadir NLWeb a tu lista de tareas es una decision estrategica. No porque sea obligatorio hoy, sino porque los agentes de IA que lo soporten van a preferir sitios que les faciliten el acceso a datos estructurados.

La web legible por maquinas ya no es el futuro. Es el presente. Y NLWeb es una de sus piezas fundamentales.

Mas guias tecnicas sobre IA y desarrollo web en Upliora. Para consultorias de implementacion de IA y web optimizada para agentes, visita Javadex.