# Feedbin: An Open-Source Ruby on Rails RSS Reader with a REST API

> Feedbin is a Ruby on Rails web application for reading and managing RSS feeds, backed by a documented REST API that third-party clients connect to. It is available as a hosted service at feedbin.com and as MIT-licensed open source, though the README explicitly warns against running it in production without significant setup time.

**feedbin/feedbin** — A nice place to read on the web.

- Repository: https://github.com/feedbin/feedbin
- Website: https://feedbin.com
- Stars: 3,781 · Forks: 290
- Language: Ruby
- License: MIT
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/feedbin-feedbin

## What Feedbin Is and the Honest Self-Hosting Warning

Feedbin is a web-based RSS reader that the README describes as simple, fast and nice looking. It provides a user interface for reading and managing feeds and a REST-like API for clients. The hosted version runs at feedbin.com.

The README is unusual in how directly it discourages self-hosting: "Feedbin's goal is to be a great web-based RSS service. This goal is at odds with being a great self-hosted RSS reader. There are a lot of moving parts and things to configure, and for that reason I do not recommend that you run Feedbin in production unless you have plenty of time to get it properly configured."

For developers who still want to self-host, the README recommends looking at three alternatives with simpler requirements: yarr, Tiny Tiny RSS, and FreshRSS. The README also links to an unofficial Docker composition maintained by a third party for those who want to try the full Feedbin stack.

This context matters: Feedbin's open-source code is maintained to support the hosted service and the REST API ecosystem, not as a community self-hosting project. Contributions and feature requests go through the hosted service support channel.

## Architecture and Dependencies

The application is a Ruby on Rails project. The README lists the requirements for running it:

- Linux or macOS
- Ruby 3.4
- Postgres 11
- Redis 6
- Elasticsearch 8.5

Elasticsearch at version 8.5 specifically is listed as a hard dependency. The `.env.example` file shows the environment variables the application needs:

```bash
export DATABASE_URL=postgres://username:password@host:port/database
export SECRET_KEY_BASE=a-long-random-string
export RACK_ENV=production
export RAILS_ENV=production
export REDIS_URL=
export REDIS_URL_CACHE=
export REDIS_URL_PUBLIC_IDS=
export ELASTICSEARCH_URL=
```

Beyond the core services, the application also requires AWS S3-compatible storage for file uploads and optionally uses Backblaze B2 for image storage through the `UNIFIED_BUCKET_IMAGES` variable set.

The main application is a Ruby on Rails application in the `app/` directory. The frontend uses Tailwind CSS and JavaScript, with `package.json` listing `tailwindcss` and `eslint` as development dependencies. The `Procfile` defines the processes that `foreman` starts.

## Installing and Starting Feedbin Locally

With Ruby, Postgres, Redis, and Elasticsearch already installed, the README gives these steps:

```bash
git clone https://github.com/feedbin/feedbin.git
cd feedbin
bundle
```

If `bundle` fails, a dependency is missing on your platform and must be resolved before proceeding. Next, rename `.env.example` to `.env` and fill in the values for your environment, at minimum `DATABASE_URL` and `SECRET_KEY_BASE`.

Create and seed the database:

```bash
rake db:setup
```

Start all the processes defined in the `Procfile`:

```bash
bundle exec foreman start
```

The README does not specify which port the application listens on locally or what the initial login credentials are, so you will need to inspect the `Procfile` and application configuration for those details.

The application has three optional companion services. Privacy Please is an HTTPS image proxy that prevents insecure content warnings when running over HTTPS. Extract is a Node.js service that fetches full article content from feeds that only provide excerpts. Pigo provides face detection for better image preview cropping and must be available in `PATH` or pointed to via the `PIGO_PATH` environment variable. None of these are required to get Feedbin running locally.

## The REST API and Third-Party Client Ecosystem

The REST-like API is a documented part of the project, with the spec maintained in a separate repository at `github.com/feedbin/feedbin-api`. Third-party RSS clients that support Feedbin connect through this API rather than directly to the database, which means the API surface is stable enough to support external development.

The `.env.example` file reveals the integrations that the API supports. Twitter integration requires `TWITTER_KEY` and `TWITTER_SECRET`. YouTube embeds require `YOUTUBE_KEY`. Rich embeds for Facebook and Micro.blog require their own tokens. Sharing service integration covers Evernote with its own key.

The `FEEDBIN_HOST` variable sets the domain from which the application is accessed and also needs an `api.example.com` subdomain enabled for API access. This means the API runs on a separate subdomain in production, not a path under the main domain.

For the full-text extraction service, the `.env.example` shows `EXTRACT_HOST`, `EXTRACT_SECRET`, and `EXTRACT_USER`. The Camo image proxy path uses `CAMO_HOST` and `CAMO_KEY`. This configuration surface is large and reflects that Feedbin is designed to power a production web service, not a personal server.

## Feedbin vs FreshRSS: Two Different Self-Hosting Philosophies

FreshRSS is a PHP-based self-hosted RSS reader that runs on a standard LAMP or LEMP stack without requiring Elasticsearch or Redis. It is a well-maintained open-source project that has been available for over a decade and is explicitly designed to be easy to self-host on low-cost VPS servers or shared hosting.

Feedbin's requirements are significantly higher. Postgres, Redis, Elasticsearch 8.5, Ruby 3.4, and optional additional services mean the full stack requires more memory and more operational knowledge. The README's own recommendation to use FreshRSS as an alternative underlines this: Feedbin was not designed with ease of self-hosting as a goal.

The difference in approach is also philosophical. FreshRSS prioritizes low-barrier self-hosting as a feature. Feedbin prioritizes a clean API surface and a well-designed web interface for a hosted SaaS product. The open source release enables client development and community inspection, not necessarily community-run instances.

## Maintenance and License

Feedbin is MIT licensed. The repository is not archived, and the last push was on 2026-09-26. There are no GitHub releases; deployment for the hosted service would happen through standard Rails deployment mechanisms rather than tagged releases. The `.ruby-version` file pins the Ruby version for the project, and the `Gemfile.lock` pins all gem dependencies. The repository includes a test suite under `test/` and uses a `Guardfile` for test watching during development.

## Conclusion

Feedbin makes sense as an open-source project to run if you are already operating a Ruby on Rails production stack and you need a well-documented REST API surface for RSS client development. For anyone else who wants a self-hosted RSS reader, the README itself points to yarr, Tiny Tiny RSS, and FreshRSS as alternatives with lower operational complexity. Before installing, verify that you can supply PostgreSQL 11, Redis 6, and Elasticsearch 8.5 alongside a Ruby 3.4 environment; without all four, the application does not run.

## FAQ

### What is Feedbin?

Feedbin is a web-based RSS reader that provides a user interface for reading and managing feeds alongside a REST API for third-party clients. It runs as a hosted service at feedbin.com and is available as open-source under the MIT license.

### Is Feedbin free?

The source code is MIT licensed and freely available. The README does not document the pricing of the hosted service at feedbin.com. For self-hosting, the code is free to run, but the README warns that the setup requires significant time and recommends simpler alternatives like yarr or FreshRSS for most users.

### Feedbin vs FreshRSS: which should I use for self-hosting?

FreshRSS is a PHP-based RSS reader built for low-barrier self-hosting on a standard web stack. Feedbin requires PostgreSQL, Redis, Elasticsearch 8.5, and Ruby 3.4, and its README explicitly recommends FreshRSS as a simpler self-hosted alternative. Choose Feedbin only if you specifically need its REST API or are already running a full Rails production environment.

### What are the free alternatives to Feedbin for self-hosting?

The Feedbin README lists yarr, Tiny Tiny RSS, and FreshRSS as alternatives to consider when looking for a self-hosted RSS reader with lower operational complexity than Feedbin.

## Sources

- [feedbin/feedbin on GitHub](https://github.com/feedbin/feedbin)
- [Issues](https://github.com/feedbin/feedbin/issues)
- [License: MIT](https://github.com/feedbin/feedbin/blob/main/LICENSE)
- [Project website](https://feedbin.com)
- [README](https://github.com/feedbin/feedbin/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/feedbin-feedbin