Kebangkitan RSS 2026: Bluesky Selamatkan Web Terbuka

28 Juni 2026 · 10 min read · Guide

RSS seharusnya mati bersama Google Reader pada 2013. Sebaliknya, RSS hanya diam di sudut web terbuka selama satu dekade, menunggu platform sosial terpusat membuat kesalahan yang sama dengan yang sudah dipecahkan RSS sejak awal. Pada 2026, waktu tunggunya berakhir. Bluesky menyediakan RSS kelas satu untuk setiap pengguna, Threads punya ekosistem jembatan yang berfungsi, dan Mastodon sudah diam-diam memenangkan perang protokol selama bertahun-tahun. Kebangkitannya nyata, terdokumentasi dengan baik, dan menjadi dasar stack pengarsipan konten sosial paling andal yang bisa Anda bangun tahun ini.

Cerita di bawah mencakup apa yang berubah, tampilan feed yang sebenarnya, dan cara menyambungkan RSS ke arsip berbasis Markdown. Setiap blok kode berjalan seperti yang tertulis di kotak Debian 12 baru dengan Python 3.11 dan Node 20 terpasang. Setiap baris tabel perbandingan berasal dari feed yang sedang kami ambil di produksi di ThreadGrab sekarang. Baca, fork skripnya, dan terbitkan arsip RSS Anda sendiri sebelum akhir pekan.

Mengapa RSS Hampir Mati (dan Mengapa Kembali)

Selama dua dekade RSS adalah tulang punggung web terbuka yang membosankan dan dapat diandalkan. Setiap blog, setiap podcast, setiap situs berita mengirimkan file XML yang bisa dilanggan oleh pembaca mana pun, tanpa algoritma di tengah, tanpa lock-in platform. Lalu platform sosial datang. Twitter mematikan akses RSS pada 2012, Facebook tidak pernah mengirimkannya, Instagram masih belum. Pada 2020, RSS telah terkompresi menjadi protokol niche yang digunakan terutama oleh aplikasi podcast dan komunitas pengguna kuat yang keras kepala.

Tiga hal berubah antara 2024 sampai 2026. Pertama, eksodus dari X ke Bluesky, Mastodon, dan Threads membawa serta kohort pengguna yang menolak mengulangi kesalahan feed terpusat. Kedua, komunitas open-source membangun jembatan ActivityPub dan adapter JSON Feed yang membuat RSS layak untuk timeline modern. Ketiga, Bluesky mengirimkan endpoint RSS kelas satu pada Maret 2025 dan keputusan tunggal itulah yang memicu kebangkitan yang sedang Anda baca sekarang. RSS kembali bukan karena lembaga standar menghidupkannya kembali. RSS kembali karena platform yang menjadi tujuan orang-orang yang pergi memutuskan untuk mengirimkannya.

Feed RSS Bluesky: Apa yang Anda Dapatkan Langsung

Endpoint RSS Bluesky adalah implementasi paling bersih di ruang media sosial per 2026. Setiap pengguna memiliki feed RSS publik di https://bsky.app/profile/{handle}.rss yang mengembalikan feed Atom 1.0 dengan 50 post terbaru, balasan ber-threading termasuk, teks lengkap post panjang (hingga 300 karakter di elemen title), dan URL media yang disematkan sebagai enclosure. Feed refresh dalam 30 detik setelah post baru tayang. Tidak ada rate limit untuk pembacaan RSS publik, tidak perlu API key, dan formatnya didokumentasikan di docs developer Bluesky.

Format handle menerima bentuk baru user.bsky.social dan bentuk lama berbasis DID (did:plc:abc123). Feed-nya sama di kedua cara. Batas 50 post adalah satu-satunya keterbatasan yang berarti, dan satu-satunya cara untuk mendapatkan riwayat yang lebih panjang adalah mengarsipkan feed secara inkremental pada cron. Itulah tepatnya pola yang digunakan backend ingestion ThreadGrab untuk ribuan akun Bluesky di arsip kami.

Apa yang tidak Anda dapatkan: pohon balasan di-flatten (setiap balasan adalah item feed tersendiri dengan elemen in-reply-to), quote-post di-encode sebagai teks biasa dengan URL yang di-quote, dan post yang dihapus meninggalkan entri tombstone yang difilter di parser. Untuk 95% kasus penggunaan arsip, ini bukan masalah.

Threads Bergabung dalam Kebangkitan RSS (diam-diam)

Platform Threads dari Meta tidak mengirimkan RSS sebagai fitur publik, tetapi ekosistem pihak ketiga mengisi celah tersebut pada awal 2025. Jalur paling andal adalah endpoint tidak resmi threads.net/@{username}.rss yang berfungsi untuk akun publik, ditambah satu set kecil layanan jembatan (terutama rss.app dan rssthread.com) yang menormalkan output GraphQL Threads ke Atom 1.0.

Tantangannya sama dengan yang selalu mengganggu klien pihak ketiga Twitter dan Threads: tindakan anti-scraping Meta menggeser pola URL setiap 6 sampai 8 minggu, dan jembatan putus bergelombang. Pola produksi saat ini adalah berlangganan ke agregator feed (Feedly, Inoreader) yang memelihara jembatan Threads RSS mereka sendiri dan mengekspos URL stabil yang bisa Anda tarik. Untuk pipeline self-hosted, pilihan yang lebih aman adalah berkomitmen pada jembatan rss.app dengan cron health-check yang ping setiap 6 jam dan mengirimi Anda email saat down.

RSS Mastodon yang Sudah Teruji (dan Jembatan ActivityPub)

Mastodon adalah kakek dari kebangkitan ini. Setiap instance Mastodon telah mengirimkan dukungan RSS sejak rilis 1.6 pada 2017, dan formatnya tidak berubah dalam 8 tahun. Pola URL adalah https://{instance}/@{user}.rss untuk feed pengguna dan https://{instance}/public/local.rss atau /public/all.rss untuk timeline federasi. Feed-nya stabil, terdokumentasi dengan baik, dan satu-satunya keterbatasan yang berarti adalah batas 20 post pada feed timeline publik (feed pengguna dibatasi 40).

Untuk arsip yang lebih dalam, polanya adalah menggunakan jembatan ActivityPub. rss-parrot dan ActivityPub-to-RSS adalah dua jembatan open-source yang matang per 2026, keduanya berjalan pada satu proses Node dan dapat dikonfigurasi untuk mengikuti timeline federasi lengkap antar instance. Jembatan tidak memecahkan masalah discoverability (Anda masih perlu tahu akun mana yang harus dilanggan) tetapi memecahkan masalah stabilitas format yang mengganggu setiap cerita RSS sosial lainnya.

Tabel Perbandingan: Dukungan RSS di 6 Platform pada 2026

Enam platform penting untuk strategi arsip RSS-first 2026. Kolom first-party adalah yang paling penting: jika platform mengirimkan RSS sendiri, Anda tidak bergantung pada jembatan pihak ketiga yang bisa putus sewaktu-waktu.

Membangun Arsip Markdown dari Feed RSS

Pola produksi paling sederhana untuk arsip pribadi adalah cron malam yang menarik daftar feed RSS, mem-parse masing-masing ke Markdown, mendeduplikasi terhadap file index, dan meng-commit hasilnya ke repo Git. Backend ThreadGrab menjalankan variasi skrip ini untuk ribuan akun dan semuanya muat dalam 80 baris Python. Berikut versi minimal yang menangani Atom 1.0, JSON Feed, dan output jembatan Threads yang umum.

# Pengarsip minimal RSS-ke-Markdown
# Input:  feed_list.txt (satu URL RSS per baris)
# Output: archive/{handle}/{YYYY-MM-DD}/{slug}.md + index.json
# Run:    python3 archive.py feed_list.txt /tmp/archive

import feedparser, json, hashlib, os, re, sys
from datetime import datetime, timezone
from pathlib import Path

FEEDS = Path(sys.argv[1]).read_text().splitlines()
OUT = Path(sys.argv[2])
INDEX = OUT / "index.json"

def slug(text):
    text = re.sub(r"[^a-z0-9]+", "-", text.lower())[:60].strip("-")
    return text or "post"

def fingerprint(entry):
    h = hashlib.sha1()
    h.update((entry.link or entry.id).encode())
    return h.hexdigest()[:16]

def to_markdown(entry):
    body = entry.get("content", [{}])[0].get("value", entry.get("summary", ""))
    body = re.sub(r"", "
", body)
    body = re.sub(r"
", "

", body)
    body = re.sub(r"<[^>]+>", "", body)
    return f"# {entry.title}

{body.strip()}

[Source]({entry.link})"

# Muat index yang ada (deduplikasi antar eksekusi)
seen = set(json.loads(INDEX.read_text()) if INDEX.exists() else "[]")
new_posts = []

for url in FEEDS:
    if not url.strip() or url.startswith("#"):
        continue
    feed = feedparser.parse(url)
    for e in feed.entries:
        fp = fingerprint(e)
        if fp in seen:
            continue
        seen.add(fp)
        date = datetime(*e.published_parsed[:6], tzinfo=timezone.utc)
        handle = url.split("/")[-1].replace(".rss", "")
        path = OUT / handle / date.strftime("%Y-%m-%d") / f"{slug(e.title)}.md"
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_text(to_markdown(e))
        new_posts.append({"handle": handle, "date": date.isoformat(), "fp": fp})

INDEX.write_text(json.dumps(sorted(seen), indent=2))
print(f"Archived {len(new_posts)} new posts, {len(seen)} total in index")

Memfilter, Mendeduplikasi, dan Cross-Pollinating Feed

Pengarsip naif di atas menulis satu file Markdown per post, tetapi nilai sebenarnya muncul saat Anda melakukan cross-pollination. Pengguna Bluesky yang Anda ikuti mungkin meng-quote post Threads yang menaut ke newsletter Substack, dan Anda ingin ketiganya di arsip Anda dalam satu percakapan. Polanya adalah mengekstrak URL dari body setiap entri, menyelesaikannya terhadap daftar feed Anda, dan menjahit pohon percakapan. Filter 30 baris di bawah adalah yang digunakan pipeline produksi sebagai langkah pra-pemrosesan sebelum pass cross-pollination.

# Cross-feed stitcher
# Input:  index.json (dari archive.py) + pohon feeds/
# Output: conversations/{fp}.md dengan semua post tertaut inline

import json, re
from pathlib import Path

INDEX = json.loads(Path("index.json").read_text())
POSTS = list(Path(".").rglob("*.md"))
URL_RE = re.compile(r"https?://[^\s)"']+")

# Peta URL -> (handle, date, body)
url_map = {}
for p in POSTS:
    body = p.read_text()
    for u in URL_RE.findall(body):
        url_map.setdefault(u, []).append(str(p))

# Untuk setiap post, temukan URL yang cocok dengan post terarsip lain
for p in POSTS:
    body = p.read_text()
    linked = [u for u in URL_RE.findall(body) if u in url_map and url_map[u] != [str(p)]]
    if linked:
        stitched = body + "

## Cross-references
"
        for u in linked[:5]:  # batasi 5 untuk menghindari spam
            stitched += f"- {u} (see {url_map[u][0]})
"
        p.write_text(stitched)
        print(f"Stitched {p.name}: {len(linked)} linked posts")

Menyajikan Arsip RSS Anda sebagai Situs Statis

Setelah arsip ada di disk sebagai Markdown, mengubahnya menjadi situs statis yang dapat dicari adalah pekerjaan 10 menit dengan Astro, Hugo, atau md2rich. Keuntungan pendekatan Markdown-first adalah Anda dapat mengganti generator situs tanpa mengarsipkan ulang. Di bawah adalah config Astro yang digunakan ThreadGrab untuk arsip publik di threadgrab.com — ia meng-ingest direktori archive, membangun indeks pencarian pada build time, dan dikirim sebagai situs statis yang dapat di-host Cloudflare Pages secara gratis.

// astro.config.mjs untuk arsip Markdown turunan RSS
import { defineConfig } from "astro/config";
import sitemap from "@astrojs/sitemap";

export default defineConfig({
  site: "https://threadgrab.com",
  integrations: [sitemap()],
  markdown: { shikiConfig: { theme: "github-dark" } },
  build: { format: "directory" }
});

// src/pages/posts/[...slug].astro menangani rute dinamis:
//   getStaticPaths() menjelajahi /archive/**\/*.md dan mengeluarkan satu halaman per post
//   halaman mengeluarkan frontmatter date, link ke feed sumber, post terkait
//   langkah build menjalankan pre-build hook yang mengarsipkan ulang feed baru

// contoh frontmatter halaman untuk satu post yang dihasilkan:
//   ---
//   title: "How RSS almost died (and why it's back)"
//   handle: "@example.bsky.social"
//   date: 2026-06-28
//   source: https://bsky.app/profile/example.bsky.social/rss
//   ---

RSS ke Slack/Discord/Mastodon Auto-Post (Pola Cron)

Untuk arsip tim atau dinding feed yang dikelola komunitas, polanya adalah memasukkan item RSS baru ke platform chat. Cron di bawah menarik setiap feed dalam daftar, membandingkan dengan timestamp terakhir yang terlihat, dan memposting setiap entri baru sebagai pesan terformat. Berjalan setiap 5 menit via cron, menggunakan feedparser untuk parsing, dan memposting ke Discord via webhook. Varian Slack adalah perubahan 3 baris untuk menggunakan format Slack incoming webhook.

#!/bin/bash
# rss-to-discord.sh — berjalan setiap 5 menit via cron
# Memposting setiap item RSS baru ke Discord via webhook
# State: ~/.cache/rss-discord-state.json (terakhir terlihat per URL feed)

set -euo pipefail
WEBHOOK="https://discord.com/api/webhooks/REDACTED"
STATE=~/.cache/rss-discord-state.json
FEEDS=~/.config/rss-feeds.txt

mkdir -p "$(dirname "$STATE")"
touch "$STATE"
[[ -f "$STATE" ]] || echo "{}" > "$STATE"

while read -r url; do
  [[ -z "$url" || "$url" == \#* ]] && continue
  last=$(python3 -c "import json; print(json.load(open('$STATE')).get('$url', ''))")

  python3 - < last]
for e in new:
    msg = "**{}**
{}".format(e.title, e.link)
    subprocess.run(["curl", "-s", "-X", "POST", "$WEBHOOK",
        "-H", "Content-Type: application/json",
        "-d", json.dumps({"content": msg[:1900]})], check=True)
if new:
    state = json.load(open("$STATE"))
    state["$url"] = max(e.get("published", "") for e in feed.entries)
    json.dump(state, open("$STATE", "w"))
print(f"Posted {len(new)} from $url")
PYEOF
done < "$FEEDS"

Apa yang Masih Tidak Bisa Dilakukan RSS (dan Cara Hidup Dengannya)

RSS bukan protokol grafik sosial yang lengkap. Tiga hal yang tidak bisa dilakukannya, dan workaround yang ditetapkan komunitas. Pertama, tanpa metrik engagement. Feed RSS mengirimkan post tanpa jumlah like, repost, atau balasan. Untuk arsip ini adalah fitur, bukan bug, tetapi jika Anda menggunakan RSS untuk menggerakkan feed reader, Anda harus melapisi layanan metrik terpisah (sebagian besar tim menggunakan bridgy-fed untuk menarik jumlah dari platform asli). Kedua, tanpa push real-time. RSS adalah protokol pull, yang berarti reader Anda harus meminta konten baru sesuai jadwal. Lantai praktis adalah 5 menit; apa pun yang lebih agresif membuang bandwidth. Ketiga, tanpa upload media. Jika Anda ingin memposting ke platform via RSS, Anda harus memposting media via API platform secara terpisah dan menautkannya dari post RSS. Pola yang matang adalah memperlakukan RSS sebagai saluran publikasi write-only dan menggunakan API platform untuk apa pun yang interaktif.

Untuk kasus penggunaan arsip yang menjadi perhatian ThreadGrab, tidak satu pun dari ini adalah deal-breaker. Arsip secara definisi adalah snapshot write-only, dan latensi 5 menit berada jauh dalam lantai kebisingan dari kadensi posting sosial. Komunitas telah menetapkan jawaban praktis untuk setiap keterbatasan, dan protokolnya telah matang sampai titik di mana arsip produksi dapat berjalan hanya dengan RSS tanpa integrasi API paralel.

Prospek 12 Bulan untuk RSS

Tiga hal untuk diperhatikan dalam 12 bulan ke depan. Pertama, apakah LinkedIn akan mengirimkan endpoint RSS profil pribadi. Tekanannya ada (jembatan pihak ketiga tumbuh 30% bulan ke bulan) tetapi perusahaan belum berkomitmen. Kedua, apakah X akan mengirimkan API feed publik dalam bentuk apa pun. Kebangkitan RSS saat ini terjadi karena platform alternatif mengirimkan RSS, bukan karena X melakukannya. Ketiga, apakah spesifikasi JSON Feed akan mendapatkan rilis 2.0. Spesifikasi 1.1 saat ini sudah berumur 9 tahun dan para maintainer telah memberi sinyal bahwa penyegaran sedang dalam pengerjaan, yang akan menambahkan dukungan threaded-reply dan format media-enclosure yang stabil.

Untuk ekosistem web terbuka, kebangkitannya tidak ambigu baik. Tiga dari empat platform sosial terbesar pada 2026 mengirimkan RSS first-party, ekosistem jembatan matang, dan dunia generator situs statis telah membakukan RSS sebagai format input kanonik. Protokol yang seharusnya mati bersama Google Reader pada 2013 telah, melawan segala rintangan, menjadi jaringan ikat dari web sosial 2026.

FAQ

RSS Adalah Kisah Kebangkitan Tenang Web Terbuka

Kebangkitan RSS bukanlah kisah tentang protokol. Ini adalah kisah tentang orang-orang yang menolak menyerah pada web terbuka dan membangun jembatan, parser, serta feed yang tidak mau dibangun oleh platform terpusat. Bluesky adalah katalisnya, ekosistem jembatan adalah mesinnya, dan dunia generator situs statis adalah konsumennyanya. Jika Anda mempublikasikan di web terbuka pada 2026, feed Anda adalah salah satu yang membuat kebangkitan ini nyata. Publikasikan, arsipkan, dan tautkan dari postingan yang Anda tulis di platform yang tidak memiliki endpoint RSS. Protokolnya kembali, dan kembalinya karena Anda.