ForHosting KIT · Web Scraping & Monitoring

Create an RSS feed

Some sites simply never published a feed — a static portfolio, a government notices page, a small news outlet running on a hand-built CMS — and no amount of discovery will find what was never made. This endpoint goes the other direction: give it a set of pages and it builds a real, valid RSS feed out of them.

● BetaPer request + per URL$0.040

Run — $0.040 + $0.001/URL How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Run it online

Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.

When there's nothing to discover

A feed reader, a monitoring tool or an automation pipeline built around RSS assumes every source has one, but plenty of legitimate publishers never adopted the format: a municipal announcements page, a university department's news section, a small e-commerce blog on a platform that never bothered to add feed support. For those sites the answer isn't finding a hidden feed, because there isn't one — it's constructing one from the pages that already exist.

What the endpoint needs and what it builds

POST a list of page URLs to /web/make-rss and a task_id comes back while each page is fetched, its title, publish date and main content extracted, and the results assembled into a single valid RSS document with proper item entries, links and dates. The finished feed follows the RSS spec closely enough that standard readers and parsers, including our own RSS to JSON endpoint, consume it without special-casing. It arrives by webhook or a signed link valid for 24 hours.

A feed is just a contract, and this fulfills it

RSS succeeded originally because it's a small, unambitious format: a channel with a title and description, and a list of items each with a title, link and date. That simplicity is exactly why it's possible to synthesize one from arbitrary pages — there's no proprietary metadata to reverse-engineer, just the handful of fields every reader expects. The generated feed behaves like any other feed to the tools that consume it, because structurally it is one.

Fitting a made feed into automation

Once a feed exists for a site that never had one, it plugs into anything built around feeds: monitoring tools that poll for changes, aggregators that need a consistent format across dozens of sources, or a personal reading setup that just wants everything in one reader. Pricing is a base fee per request plus a per-URL charge, so building a feed from three pages costs a small fraction of building one from three hundred, and the cost scales with exactly the work done rather than a flat rate that overcharges small jobs or undercharges large ones. A failed extraction on an individual page is never charged, so an occasional broken URL in the batch doesn't inflate the bill.

What you can do with it

Feed for a site with no RSS support

Build a working feed from a municipal or university announcements page so it can be monitored the same way as any modern blog.

Reviving an abandoned or platform-limited blog

Generate a feed for a small business blog running on a platform that never added native RSS output.

Consistent aggregation across mixed sources

Create feeds for the handful of sources in a news aggregator that lack native RSS, so every source can be polled the same way.

Personal reading list automation

Turn a set of bookmarked pages from feed-less sites into one feed to follow updates from a single reader app.

FAQ

How do I create an RSS feed from a website with the API?

POST a list of page URLs to /web/make-rss, keep the returned task_id, and collect the generated RSS document by webhook or a signed link valid for 24 hours.

Is the create RSS API free?

No, there is no free tier or trial; it costs $0.040 per request plus $0.001 per URL submitted, and a failed generation is never charged.

What if the site already has a feed?

Use the RSS discovery endpoint first — it's cheaper and faster to find an existing feed than to build one that would duplicate it.

How many URLs can I submit in one request?

You can submit as many page URLs as the site has; cost scales linearly with the per-URL charge, so larger feeds simply cost proportionally more.

Will the generated feed work in standard RSS readers?

Yes, it follows the RSS specification closely enough that standard readers and parsers consume it without any special handling.

What data does each feed item include?

Title, link, publish date and main content extracted from each submitted page, assembled into standard item entries.

Can I regenerate the feed later to pick up new pages?

Yes, submit an updated list of URLs whenever the site adds pages and the feed is rebuilt from the current set you provide.

Is the source page content stored after the feed is built?

No, fetched pages and generated feeds are deleted after the retention window and are never used for training.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/web/make-rss

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/web/make-rss \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"url":"https://ejemplo.com"}'

const res = await fetch("https://api.kit.forhosting.com/web/make-rss", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "url": "https://ejemplo.com"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/web/make-rss",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "url": "https://ejemplo.com"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/make-rss", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"url":"https://ejemplo.com"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"url":"https://ejemplo.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/make-rss", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "url": "https://ejemplo.com"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "web.make_rss",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.040

Per URL$0.001

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`timeout_sec`	30
`max_crawl_pages`	25

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.
`422`	`task_failed`	The task failed after 3 retries. You are never charged for it.

Read the full KIT documentation →