How to connect your RSS feeds to AI agents

SereneReader/March 5, 2026/Updated October 6, 2026/aiapiagents

Why RSS plus AI agents works

AI agents that read the web often start by scraping pages. That means parsing HTML, rendering JavaScript, handling rate limits and CAPTCHAs, and fixing page selectors whenever a site changes its layout.

SereneReader fetches your RSS feeds, parses them, and stores the articles as structured data. The API returns that data as JSON, so your agent works with titles, links, authors, dates and summaries instead of web pages.

Structured JSON. Your agent doesn't handle RSS or XML. SereneReader has already parsed the feeds, decoded HTML entities, fixed double-encoded content and normalized encoding quirks, so the agent queries the API and gets structured JSON back.

Sources you choose. You pick the feeds, so the agent only sees sources you've chosen.

No scraping. Your agent calls the SereneReader API and never contacts the source websites, so robots.txt rules and anti-bot measures don't come into it.

Date filtering. Results come back newest first, and you can ask for articles published since a given time. Feeds sometimes publish items late or with older dates, so if your agent must never miss or repeat an item, have it keep track of the article IDs it has already processed.

How it works with OpenClaw

As of October 2026, OpenClaw is an open-source AI assistant that runs on your own computer and that you talk to through chat apps such as WhatsApp, Telegram or Discord. You extend it with skills, which can call external APIs. To connect it to SereneReader:

Create an API key in SereneReader under Settings > API (on the Pro and Team plans).
Add a skill for the SereneReader API. The API tab in Settings lists the endpoints, parameters and example requests your skill needs.
Give the assistant a task. For example: "Check my RSS feeds every morning, summarize anything related to infrastructure security, and save a summary to my Obsidian vault."

The assistant handles scheduling, filtering and summarizing. SereneReader handles fetching feeds and storing articles.

Example agent prompt

Here's roughly what the agent instructions might look like:

You have access to the SereneReader API. Every day at 8am, fetch articles published in the past 24 hours. For each article, determine if it relates to cybersecurity, infrastructure, or DevOps. If it does, add it to a daily summary. Save the summary as a new note in my Obsidian vault under the Daily Digests folder.

The agent calls the API, processes the results and saves the note. If your agent platform can run tasks on a schedule, you don't need to write any code for this. If it can't, the script further down does the same job with cron.

Example use cases

News monitoring agent

Subscribe to 20-30 industry feeds in SereneReader. Connect an agent that scans for mentions of your company, competitors, or specific topics. Get a daily briefing instead of checking each feed yourself.

Research digest

Follow academic preprint feeds (arXiv, bioRxiv) and technical blogs. Have an agent categorize new papers by topic, flag anything relevant to your current projects, and compile a weekly reading list.

Content pipeline

Subscribe to feeds in your niche. Let an agent identify trending topics, extract key points, and draft content briefs. You still write the content, but the agent does the first pass of research.

Competitive intelligence

Track competitor blogs, changelog feeds, and press releases. An agent can spot product launches, pricing changes, and feature announcements, then log them in a structured format.

Works with other LLM tools

The SereneReader API returns standard JSON over HTTP, so any tool that can make authenticated API requests can use it:

OpenClaw for an assistant that runs tasks for you
LangChain / LlamaIndex for retrieval-augmented generation
Custom scripts with any LLM API via OpenRouter (see example below)
Zapier / Make for no-code automation with AI steps
n8n for self-hosted workflow automation

The pattern is usually the same: fetch articles from SereneReader, pass them to an LLM, and send the output wherever it needs to go.

Example: daily digest script with OpenRouter

A Node.js script that fetches the past 24 hours of articles from SereneReader, summarizes them with a model you choose through OpenRouter, and writes the result to a local file. Set SERENE_API_URL to the full articles endpoint (the base URL from the API tab in Settings, followed by /api/v1/articles), and set OPENROUTER_MODEL to the OpenRouter ID of the model you want (for example, a Claude model from OpenRouter's model list). Run it with node digest.mjs, or schedule it with cron.

As written, the script reads one page of results, and the API returns 50 articles per page by default. If your feeds publish more than that in a day, add the limit parameter (up to 200) or page through the results with offset.

// digest.mjs
// Requires: SERENE_API_KEY, SERENE_API_URL, and OPENROUTER_API_KEY env vars.
// Your API settings page in SereneReader has the base URL and endpoint paths.

const SERENE_API_KEY = process.env.SERENE_API_KEY;
const SERENE_API_URL = process.env.SERENE_API_URL; // from your API settings page
const OPENROUTER_API_KEY = process.env.OPENROUTER_API_KEY;

import { writeFileSync } from "node:fs";

// 1. Fetch yesterday's articles from SereneReader
const yesterday = new Date(Date.now() - 86400000).toISOString();
const res = await fetch(`${SERENE_API_URL}?since=${yesterday}`, {
  headers: { Authorization: `Bearer ${SERENE_API_KEY}` },
});

if (!res.ok) {
  console.error(`SereneReader API error: ${res.status}`);
  process.exit(1);
}

const { articles } = await res.json();

if (articles.length === 0) {
  console.log("No new articles since yesterday.");
  process.exit(0);
}

// 2. Build a prompt from article titles and snippets
const articleList = articles
  .map((a) => `- ${a.title} (${a.feedName})\n  ${a.snippet}`)
  .join("\n\n");

const prompt = [
  `Here are ${articles.length} articles from my RSS feeds`,
  `published in the last 24 hours:\n\n${articleList}\n\n`,
  `Write a concise daily digest. Group related articles`,
  `by topic. For each topic, summarize the key points in`,
  `2-3 sentences. Include the article titles so I know`,
  `which ones to read in full.`,
].join(" ");

// 3. Send to any model via OpenRouter
const llmRes = await fetch("https://openrouter.ai/api/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${OPENROUTER_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: process.env.OPENROUTER_MODEL, // set to the model ID you want from openrouter.ai/models
    messages: [{ role: "user", content: prompt }],
  }),
});

if (!llmRes.ok) {
  console.error(`OpenRouter API error: ${llmRes.status}`);
  process.exit(1);
}

const { choices } = await llmRes.json();
const summary = choices[0].message.content;

// 4. Write the digest to a local markdown file
const date = new Date().toISOString().split("T")[0];
const output = `# Daily Digest - ${date}\n\n${summary}\n`;
writeFileSync(`digest-${date}.md`, output);

console.log(`Digest written to digest-${date}.md (${articles.length} articles)`);

The script has no dependencies and no build step. Swap the model, change the prompt, or send the output to Obsidian, Notion or Slack instead of a file.

Getting started

API access is included with Pro ($5/month on the web) and Team.

Sign up for SereneReader if you haven't already.
Subscribe to the feeds you want your agent to read.
Create an API key in Settings > API.
Configure your agent to call the SereneReader API.

The API tab in Settings has the full endpoint reference. For more on the API itself, read Building automations with the SereneReader API.