RSS segueix sent una peça brutal per automatitzar informació el 2026

Cada cop que algú diu que RSS està mort, em fa la sensació que no ha automatitzat res a la seva vida. O que confon la mort de Google Reader amb la mort del protocol. RSS no només no ha mort, sinó que el 2026 és una de les peces més infravalorades per construir sistemes d’automatització d’informació fiables.

Ho dic des de l’experiència. Porto mesos construint Rolsfera, un agregador de notícies que combina RSS, scraping i IA. I si hagués de quedar-me amb una sola font de dades, em quedaria amb RSS sense pensar-m’ho. No perquè sigui la més potent, sinó perquè és la més previsible. I en automatització, previsible val més que potent.

Aquest article no és un tutorial. És una defensa tècnica i fonamentada de RSS com a infraestructura per a automatització, amb comparacions reals davant de scraping i APIs. Si treballeu amb fluxos d’informació, agents d’IA o agregadors de contingut, crec que val la pena replantejar-se el paper de RSS al vostre stack.

El que RSS fa bé (i que gairebé ningú valora)

RSS és un format XML estandarditzat per distribuir contingut actualitzat. Això ja ho saps. El que potser no has pensat és per què aquestes característiques tècniques són tan valuoses quan construeixes automatitzacions:

Format previsible. Un feed RSS sempre té la mateixa estructura. Títol, enllaç, data, resum. Sempre. No importa si és un blog de WordPress, un diari digital o un repositori de GitHub. El format és el mateix. Això vol dir que un parser de RSS serveix per a totes les fonts, sense adaptació per lloc.

Sense autenticació. La immensa majoria de feeds RSS són públics. No necessites API key, no necessites OAuth, no necessites registrar-te a cap plataforma. Apuntes a la URL del feed i llegeixes.

Sense rate limits. No hi ha cap servidor de RSS que et bloquegi per fer 10 peticions al dia. Els feeds estan dissenyats per ser consumits periòdicament. És literalment el seu propòsit.

Detecció de contingut nou. RSS resol de manera nativa el problema de “hi ha alguna cosa nova?”. Cada entrada té una data de publicació i un identificador únic. No necessites comparar snapshots d’HTML ni mantenir un historial de hashes.

RSS és l’API més estable que existeix, i ningú la manté perquè no necessita manteniment.

RSS vs scraping: estabilitat davant de flexibilitat

He usat tots dos extensivament a Rolsfera i la diferència en cost de manteniment és abismal.

El scraping guanya en flexibilitat. Si necessites extreure el preu d’un producte, el nombre de comentaris d’un article o una dada específica que el feed no inclou, no hi ha alternativa. Però per al cas d’ús més comú en automatització d’informació, que és detectar contingut nou i obtenir títol, enllaç i resum, RSS guanya en tots els fronts.

A Rolsfera, de les 40+ fonts que consumeixo, 30 s’alimenten exclusivament via RSS. Les altres 10 usen scraping perquè el lloc no té feed o perquè necessito dades que el feed no inclou. La diferència en manteniment és clara: els scrapers em donen problemes cada poques setmanes. Els feeds RSS no m’han donat ni un sol problema en mesos.

RSS vs APIs: accés, cost i dependència

L’altra comparació rellevant és amb APIs. Moltes plataformes de contingut ofereixen APIs per accedir a les seves dades: Reddit, Hacker News, Dev.to, Medium (parcialment), GitHub.

Les APIs et donen dades més riques. Si necessites recompte de likes, comentaris, historial d’edicions o metadades específiques d’una plataforma, l’API és el camí. Però per al cas d’ús de “vull saber què ha publicat aquesta font recentment”, RSS és més simple, més barat i més estable.

Un exemple concret: l’API de Reddit té rate limits estrictes (100 peticions per minut al tier gratuït), requereix OAuth2 i ha canviat les seves condicions diverses vegades. El RSS de Reddit (reddit.com/r/python/.rss) no té res d’això. És una URL pública que retorna els últims posts en format estàndard.

Quan construeixes una automatització que consumeix desenes de fonts, cada API que afegeixes és un punt de complexitat: una autenticació que gestionar, un rate limit que respectar, unes condicions de servei que poden canviar. RSS elimina tota aquesta fricció.

Per què RSS encaixa amb l’era de LLMs i agents

Aquí és on la cosa es posa interessant. El 2026, l’ecosistema d’agents d’IA i automatitzacions intel·ligents està en plena expansió. I RSS encaixa sorprenentment bé en aquest ecosistema per diverses raons.

RSS com a font d’entrada per a agents

Un agent d’IA que necessita estar informat sobre un tema necessita una font de dades estructurada, actualitzada i fiable. RSS compleix els tres requisits. No necessites que l’agent sàpiga scraping, no necessites que gestioni autenticacions, no necessites que interpreti HTML. Li dones una llista de feeds i ja té accés a informació actualitzada de desenes de fonts.

# Un agente simple que consume RSS para mantenerse informado
import feedparser

def get_latest_news(feeds: list[str], max_per_feed: int = 5) -> list[dict]:
    """Fuente de datos para un agente de IA."""
    all_articles = []
    for feed_url in feeds:
        feed = feedparser.parse(feed_url)
        for entry in feed.entries[:max_per_feed]:
            all_articles.append({
                "title": entry.get("title", ""),
                "url": entry.get("link", ""),
                "summary": entry.get("summary", ""),
                "published": entry.get("published", ""),
                "source": feed_url,
            })
    return sorted(all_articles, key=lambda x: x["published"], reverse=True)

RSS com a input per a pipelines d’IA

A Rolsfera, RSS és el primer graó d’un pipeline que acaba amb classificació per IA, generació de resums i publicació automatitzada. El flux és:

RSS → Parser → Deduplicació → LLM (classificació + resum) → Publicació

L’estabilitat de RSS a la primera fase és el que permet que la resta del pipeline funcioni de manera fiable. Si la font de dades fos scraping, hauria de lidiar amb trencaments constants que propagarien errors a tot el sistema. Amb RSS, la ingesta és la part més estable del pipeline.

RSS com a protocol per a comunicació entre sistemes

Una cosa que se sol oblidar: RSS no és només per consumir contingut de tercers. També és un format excel·lent perquè els teus propis sistemes publiquin dades. Si tens un servei que genera alertes, informes o resums, exposar un feed RSS és una manera trivial que altres sistemes (o persones) els consumeixin.

A Rolsfera estic plantejant que la pròpia sortida de l’agregador sigui un feed RSS. És irònic, ho sé: consumeixo RSS, processo amb IA i torno a publicar com a RSS. Però té sentit. Qualsevol lector de feeds o automatització pot subscriure’s a la sortida de Rolsfera sense necessitat d’una API dedicada.

RSS com a capa de monitorització

Un ús que vaig descobrir gairebé per accident: RSS com a sistema de monitorització lleugera. Molts serveis exposen feeds amb els seus canvis, releases o incidències. GitHub té feeds de releases per repositori. AWS té feeds d’estat de serveis. Moltes eines de CI/CD publiquen resultats via RSS.

En lloc de muntar integracions específiques amb cada servei, puc subscriure’m als seus feeds i processar-los amb el mateix pipeline que uso per a notícies. Un agent que consumeix el feed de releases de les teves dependències crítiques i t’avisa quan hi ha una nova versió és alguna cosa que muntes en una tarda amb RSS i un parell de scripts.

# Monitorización de releases de GitHub vía RSS
GITHUB_RELEASE_FEEDS = [
    "https://github.com/python/cpython/releases.atom",
    "https://github.com/n8n-io/n8n/releases.atom",
    "https://github.com/fastapi/fastapi/releases.atom",
]

def check_new_releases(feeds: list[str]) -> list[dict]:
    """Detecta releases nuevos en las últimas 24h."""
    from datetime import datetime, timedelta
    cutoff = datetime.utcnow() - timedelta(hours=24)
    new_releases = []

    for feed_url in feeds:
        feed = feedparser.parse(feed_url)
        for entry in feed.entries:
            published = entry.get("published_parsed")
            if published and datetime(*published[:6]) > cutoff:
                new_releases.append({
                    "project": feed.feed.get("title", ""),
                    "version": entry.get("title", ""),
                    "url": entry.get("link", ""),
                    "date": entry.get("published", ""),
                })

    return new_releases

Intentar fer això mateix amb APIs requereix autenticació amb cada servei, gestionar rate limits diferents i parsejar respostes JSON amb estructures distintes. Amb RSS, el codi és genèric.

Els límits reals de RSS

No vull pintar un escenari idíl·lic. RSS té limitacions clares i és important conèixer-les:

Contingut incomplet. Molts feeds només inclouen un extracte de l’article, no el text complet. Per obtenir el contingut íntegre necessites seguir l’enllaç i, en molts casos, fer scraping de la pàgina.

Sense mètriques d’engagement. RSS no et diu quantes persones han llegit un article, quants likes té o quants comentaris ha generat. Si necessites aquest tipus de senyals per prioritzar contingut, necessites complementar amb altres fonts.

Feeds abandonats o mal configurats. Alguns llocs tenen feeds RSS que porten anys sense actualitzar-se o que estan mal configurats (dates incorrectes, encoding trencat, HTML escapat dins l’XML). No és un problema del protocol, sinó de la implementació de cada lloc.

Descobriment. No hi ha un directori universal de feeds RSS. Trobar el feed d’un lloc de vegades requereix buscar a l’HTML de la pàgina, provar URLs comunes (/rss, /feed, /atom.xml) o usar eines de descobriment.

# Función para descubrir feeds en una página
from bs4 import BeautifulSoup
import requests

def discover_feeds(url: str) -> list[str]:
    """Busca feeds RSS/Atom en una página web."""
    feeds = []
    try:
        response = requests.get(url, timeout=10)
        soup = BeautifulSoup(response.text, "html.parser")

        # Buscar enlaces de tipo feed en el <head>
        for link in soup.find_all("link", type=True):
            if "rss" in link.get("type", "") or "atom" in link.get("type", ""):
                href = link.get("href", "")
                if href:
                    if not href.startswith("http"):
                        href = f"{url.rstrip('/')}/{href.lstrip('/')}"
                    feeds.append(href)

        # Probar URLs comunes si no encontramos nada
        if not feeds:
            common_paths = ["/rss", "/feed", "/atom.xml", "/rss.xml", "/feed.xml"]
            for path in common_paths:
                test_url = f"{url.rstrip('/')}{path}"
                try:
                    r = requests.head(test_url, timeout=5, allow_redirects=True)
                    if r.status_code == 200:
                        feeds.append(test_url)
                except Exception:
                    pass

    except Exception as e:
        print(f"Error descubriendo feeds en {url}: {e}")

    return feeds

Latència. RSS no és temps real. La freqüència d’actualització d’un feed depèn del lloc. Alguns actualitzen cada pocs minuts, altres cada hores. Si necessites informació en temps real, RSS no és la teva eina (però tampoc el scraping, en general).

Aplicació pràctica a Rolsfera

A Rolsfera, RSS és la columna vertebral del sistema d’ingesta. Així l’uso a la pràctica:

Descobriment de contingut nou. Cada 30 minuts, el sistema llegeix tots els feeds configurats i detecta articles nous comparant amb la base de dades. Aquest és el trigger de tot el pipeline.

Primer nivell de dades. Títol, URL, data de publicació i resum curt. Amb això ja puc fer deduplicació, filtrat per keywords i una classificació inicial.

Font de veritat per a URLs. La URL que ve al feed és la URL canònica de l’article. Això és important per a la deduplicació: si dos scrapers extreuen el mateix article amb URLs lleugerament diferents, la URL del RSS serveix com a referència.

Monitorització de fonts. Tinc un dashboard simple que mostra quants articles ha retornat cada feed les últimes 24 hores. Si un feed que normalment publica 5 articles diaris porta dos dies sense publicar, el reviso. De vegades el feed s’ha trencat, de vegades el lloc ha canviat d’URL, de vegades simplement no han publicat res.

Complement amb scraping selectiu. Per a les fonts el feed de les quals només inclou un extracte, uso l’enllaç del RSS per fer scraping del contingut complet. RSS em dona la senyal que hi ha alguna cosa nova; el scraping em dona el contingut detallat. És una combinació que funciona bé perquè cada part fa el que millor sap fer.

L’argument de fons

RSS és infraestructura. No és glamurós, no és modern, no surt en demos de productes d’IA. Però compleix una funció que cap altra tecnologia compleix amb la mateixa simplicitat: distribuir contingut estructurat de manera oberta, estàndard i sense fricció.

En un ecosistema on les APIs canvien les seves condicions de servei, el scraping es trenca cada setmana i les plataformes tanquen accessos per monetitzar les seves dades, RSS és una àncora d’estabilitat. No depèn d’una empresa, no requereix pagament, no té rate limits pràctics i porta funcionant amb la mateixa especificació des de fa més de dues dècades.

No necessites que RSS sigui la solució a tot. Només necessites reconèixer que per a molts casos d’ús segueix sent la solució més simple i fiable. I en enginyeria, simple i fiable sol ser la millor combinació.

Quan veig projectes d’automatització que comencen muntant scrapers complexos o integracions amb APIs de pagament per resoldre alguna cosa que un feed RSS resoldria en 10 línies de codi, em queda clar que el problema no és tècnic. És de percepció. RSS no té màrqueting. No té una empresa al darrere fent demos a conferències. No genera hype. I per això s’ignora.

Però segueix aquí. Funciona. I el 2026, amb agents d’IA que necessiten fonts de dades estructurades i fiables, és més rellevant que mai.

Un exercici pràctic: munta el teu primer pipeline RSS en 10 minuts

Si mai has treballat amb RSS de manera programàtica, aquest és el punt d’entrada més simple que conec:

pip install feedparser

import feedparser
import json

# Elige un feed que te interese
feed = feedparser.parse("https://news.ycombinator.com/rss")

# Muestra los 5 artículos más recientes
for entry in feed.entries[:5]:
    print(f"- {entry.title}")
    print(f"  {entry.link}")
    print()

# Guarda en JSON para procesamiento posterior
articles = [
    {"title": e.title, "url": e.link, "published": e.get("published", "")}
    for e in feed.entries
]

with open("articles.json", "w") as f:
    json.dump(articles, f, indent=2, ensure_ascii=False)

Amb aquestes 15 línies ja tens un extractor funcional. A partir d’aquí pots afegir deduplicació, filtrat, emmagatzematge a base de dades o processament amb IA. Però el punt de partida és aquest: una URL i un parser. Sense API keys, sense autenticació, sense rate limits.

Per acabar

No t’estic dient que deixis d’usar APIs o que no facis scraping. Cada eina té el seu lloc. El que sí et dic és que si estàs construint qualsevol tipus d’automatització que treballi amb informació pública, hauries de considerar RSS abans de complicar-te amb alternatives més fràgils.

A Rolsfera, RSS és la peça que menys problemes em dona i la que més valor aporta per línia de codi invertida. Això, per a un projecte personal que mantinc en el meu temps lliure, no és un detall menor. És la diferència entre un sistema que puc mantenir i un que em consumeix.

I si després de llegir tot això segueixes pensant que RSS està mort, et convido a comptar quants feeds consumeixes sense saber-ho. El teu lector de podcasts usa RSS. El teu client de newsletters probablement usa RSS per sota. Moltes de les eines de monitorització que uses a la feina consumeixen feeds. RSS no ha mort. Només ha deixat de necessitar que en parlis perquè segueixi funcionant.