Isso

Self-hosted commenting for static sites and blogs, honestly reviewed. No marketing fluff.

TL;DR

• What it is: Isso is a lightweight, MIT-licensed commenting server written in Python. It’s designed as a drop-in Disqus replacement for static sites, blogs, and any website where you’d rather not hand your readers’ data to a third party [2].
• Who it’s for: Bloggers, indie developers, and small publishers running static sites (Hugo, Jekyll, Ghost, WordPress) who want comments without Disqus’s tracking, ads, or opaque data practices.
• Cost: $0 for the software (MIT). Your only recurring cost is the VPS it runs on — $4–6/month on Hetzner or DigitalOcean is plenty [5].
• Key strength: Brutally simple. A single JS embed, a SQLite database, and a Python process. Nothing else. It supports anonymous comments with identity persistence, Markdown, and moderation queues out of the box [2].
• Key weakness: The project has been slow-moving. The GitHub page doesn’t publish star or fork counts in the metadata provided, but the codebase is mature and the feature set is deliberately frozen at “what you need for a blog” — not “what you need for a community platform.” If you want voting, reactions, spam filtering, or user accounts, Isso isn’t the tool.

---

What is Isso

Isso — the name is German for Ich schrei sonst (“I’ll scream otherwise”) — is a commenting server built to do one specific thing: let people leave comments on your website without you routing those comments through Disqus, IntenseDebate, or any other third-party service that logs IP addresses, emails, and behavioral data about your readers [2].

The technical pitch is aggressively minimal. You run a Python process, point it at a SQLite database file, configure which domains it accepts comments from, and embed a 65kB JavaScript file (20kB gzipped) on your site [1]. That’s the whole system. No Redis, no Postgres, no message queue. SQLite, because as the README puts it: “comments are not Big Data.”

The project sits at 5,270 GitHub stars and is MIT-licensed, meaning you can self-host it, fork it, embed it in your own product, or redistribute it without restrictions. The official documentation lives at isso-comments.de, and there’s an active Docker image maintained at ghcr.io/isso-comments/isso.

What it deliberately is not: a community platform, a forum replacement, or a full-featured SaaS competitor. It’s the minimum viable commenting system for a blog that wants to own its data.

---

Why People Choose It

The core case against Disqus is laid out bluntly in Isso’s own documentation: “No anonymous comments (IP address, email and name recorded), hosted in the USA, third-party. Just like IntenseDebate etc. When you embed Disqus, they can do anything with your readers (and probably mine Bitcoins, see the loading times)” [2].

That’s a real complaint, not marketing copy. Disqus’s free tier runs ads and collects behavioral data. Their paid tier (Disqus Plus) removes ads but doesn’t change the fundamental architecture: your readers’ comments and identities live on Disqus’s servers, not yours. For a privacy-focused blogger or a European publisher worried about GDPR, that’s a hard no.

Isso solves this with the simplest possible answer: run the comment server yourself. The chringel.dev case study [3] — a developer migrating their Hugo blog away from Disqus — captures the typical adoption path: install Isso via pip, write a config file with two required fields (dbpath and host), set up a reverse proxy subdomain, and drop the embed script into your site template. The Hugo integration reduces to a partial that checks for Isso config and renders the client [3].

What users consistently report works well:

• Anonymous commenting with persistent identity (Isso stores a hash in a cookie so repeat visitors appear consistent without requiring an account)
• No sign-up friction — visitors can comment without creating accounts anywhere
• Moderation queue — optionally require approval before comments go public [1]
• The embed is genuinely lightweight — 65kB uncompressed, 20kB gzipped [1]
• Disqus import works, so migration isn’t starting from scratch

The Linux Handbook tutorial [5] notes that Isso works with WordPress, Ghost, and static site generators, which covers most of the realistic use cases.

---

Features

Based on the README and documentation:

Core commenting engine:

• Comments written in Markdown [1][2]
• Users can edit or delete their own comments within a configurable window (15 minutes by default) [1]
• Anonymous comments supported; identity persisted via cookie hash
• Moderation queue — comments held for approval before becoming public [1]
• Email notifications for new comments via SMTP [1]
• Threading supported (replies to comments)

Data and storage:

• SQLite backend — single file, simple to back up, no separate database process [2]
• Disqus XML export import [1]
• WordPress export import [1]
• Full server API for programmatic access [2]

Integration:

• Single JS embed: <script data-isso="//comments.example.tld/" src="//comments.example.tld/js/embed.min.js"></script> [1]
• Works with any HTML page — static sites, Hugo, Jekyll, Ghost, WordPress [3][5]
• CORS configured per-domain; no wildcard allowed [1]
• Multiple hosts per config supported (e.g., HTTP + HTTPS, localhost for dev) [1]
• Multiple sites require separate configs or the multi-site setup documented separately [1]

Deployment options:

• pip install from PyPi [1]
• Docker image at ghcr.io/isso-comments/isso:release [README]
• Stable releases pinned by tag (e.g., isso:0.13.0) — maintainers recommend pinning [README]
• Requires Python 3.8+, SQLite 3.3.8+, a C compiler for source builds

What’s missing (by design):

• No built-in spam filtering — moderation queue is the only gate
• No user accounts or authentication
• No voting or reactions out of the box (configurable in some setups)
• No analytics or comment counts aggregation beyond what the API provides
• No rich media embeds in comments
• SSO, LDAP, or OAuth: not supported

---

Pricing: SaaS vs Self-Hosted Math

Disqus for comparison:

• Free tier: ad-supported, data collected, commenting available
• Plus (ad-free): approximately $11/month — pricing has changed multiple times and data on exact current tiers is not available in provided sources; check Disqus directly
• Disqus does not publish a fixed public pricing page that was scraped for this review, so treat the $11/month figure as approximate

Isso self-hosted:

• Software license: $0 (MIT)
• VPS to run it: $4–6/month on Hetzner or DigitalOcean for a 1GB RAM machine [5]
• SQLite database backup: free (it’s a single file; rsync it somewhere)
• SSL: free via Let’s Encrypt, handled by the reverse proxy [5]
• SMTP for moderation emails: free tier from any transactional provider, or your existing email

Concrete math:

A blogger running one site with ~50 comments per month has zero reason to pay Disqus $11/month when Isso on a shared $5 VPS achieves the same thing with full data ownership. If you’re already running other self-hosted services on a VPS — a blog, a small app, anything — Isso adds essentially nothing to the infrastructure cost because the resource footprint is negligible.

The only scenario where the math tilts back toward Disqus is if you’re currently on their free ad-supported tier and you have no server to run Isso on. In that case you’re trading a $0/month opaque service for a $5–6/month transparent one. That’s a values question, not a savings question.

---

Deployment Reality Check

The Linux Handbook tutorial [5] and the official quickstart [1] give an accurate picture of what setup actually involves.

Minimum viable setup:

1. A Linux VPS (1GB RAM is enough for a low-traffic blog) [5]
2. Python 3.8+ with pip, or Docker
3. A config file with at minimum dbpath and host fields [1]
4. A reverse proxy (Nginx or Caddy) handling SSL on a subdomain like comments.yourdomain.com [1][5]
5. The embed script added to your site template [1][3]

The config file is two required fields:

[general]
dbpath = /var/lib/isso/comments.db
host = https://example.tld/

Everything else has defaults [1]. That’s a genuinely low barrier.

Docker path is the easier production route. The official image exists, the Linux Handbook tutorial [5] shows a full Docker Compose setup with Nginx reverse proxy and Let’s Encrypt. The main gotcha: the Docker image tagging changed in March 2024 — :latest now tracks master (development builds), while :release tracks stable versions. Pin to a specific release tag like isso:0.13.0 to avoid surprises [README].

Hugo integration [3] is a config parameter plus a partial template — straightforward if you’ve touched Hugo before, confusing if you haven’t, because every additional Isso client option needs to be added both to config.toml and to the template as a data- attribute.

What can go sideways:

• CORS errors are the most common setup problem. Isso’s host list is strict — no wildcards, and you need to list every variant (HTTP, HTTPS, www, non-www) [1].
• The C compiler dependency for pip installs catches people on minimal server images that don’t have build tools.
• If you miss pinning the Docker tag, a docker pull after March 2024 may give you a development build [README].
• Multi-site support requires reading a separate documentation section — a single Isso instance cannot serve multiple independent sites without extra configuration [1].
• Email moderation requires SMTP setup, and if you skip it, moderation links only appear in logs [1].

Realistic time estimates: 20–30 minutes for a developer who has deployed a Docker container before. 1–3 hours for someone who hasn’t, including domain DNS propagation time. The chringel.dev writeup [3] describes the full Hugo integration as “that’s it, you’re done” — which is accurate if you already have Isso running.

---

Pros and Cons

Pros

• MIT license, genuinely. No “Fair-code,” no commercial restrictions, no license audits. Self-host, fork, embed, redistribute — no lawyers needed.
• Zero external dependencies. SQLite means your entire comment history is one file. Backup is rsync. No database server to maintain.
• Anonymous commenting works. Isso lets visitors leave comments without signing up for anything. For a blog, this is a meaningful UX advantage — most people don’t comment if it requires creating an account.
• Extremely lightweight embed. 65kB JS (20kB gzipped) [1]. Disqus is notoriously heavy and slow. This matters for page speed scores.
• Disqus and WordPress import. Migration path exists and is documented [1]. You don’t lose historical comments.
• Moderation queue. Optional, but configurable. You can approve comments before they go public [1].
• Markdown in comments. A quality-of-life feature that matters if your audience can write Markdown.
• Works with any static site generator. Hugo [3], Jekyll, Ghost [5], plain HTML — the embed script doesn’t care [1].

Cons

• No spam filtering. The moderation queue is the only defense. On a high-traffic site or after a post goes viral, this gets painful fast. There’s no Akismet integration, no honeypot, no rate limiting visible in the documentation.
• Single-site per config by default. Serving comments for multiple independent sites from one Isso instance requires extra configuration [1]. Not a dealbreaker but adds setup complexity.
• No user accounts or reputation. Anonymous-by-default is a privacy feature, but it also means no way to highlight trusted commenters, ban abusers persistently, or build any community identity layer.
• Development pace is slow. The project is mature but not actively growing. The feature set is stable, which is a polite way of saying it won’t get the integrations, spam filtering, or analytics features that competing tools have been adding.
• Requires a C compiler for source installs. pip install isso fails on minimal server images without build tools [README]. Docker sidesteps this but adds a layer of abstraction.
• Email notifications require SMTP setup. Not included or preconfigured. If you skip it, moderation is log-only [1].
• No voting or reactions. Some users expect basic thumbs-up functionality. Isso doesn’t have it.
• No mobile app or admin UI. Management is config file + moderation links sent by email. There’s no web dashboard for comment management.

---

Who Should Use This / Who Shouldn’t

Use Isso if:

• You run a personal blog or small publication and you want comments without Disqus’s tracking and ads.
• You already have a VPS running other services and can add Isso to the mix for effectively zero additional cost.
• Your audience is comfortable typing in a box without signing into a platform.
• You want to own your comment data as a SQLite file you can query, back up, and migrate freely.
• You’re integrating with a static site generator like Hugo or Jekyll and want something that drops in with a template partial [3].
• You want a GDPR-friendly commenting solution — comments stored on your server, in your jurisdiction, under your control.

Skip it (pick Remark42 instead) if:

• You want OAuth login options (GitHub, Google, Twitter) alongside anonymous commenting.
• You need voting/reactions.
• You want an admin UI for managing comments without digging through logs.
• You’re building for a multi-author publication and need role-based moderation.

Skip it (pick Commento or Cusdis) if:

• You want a managed SaaS option that’s privacy-respecting but without the ops burden.
• Your team doesn’t have anyone comfortable deploying and maintaining a Python service.

Skip it (stay on Disqus free) if:

• You have very low traffic and comment volume and genuinely don’t care about the tracking trade-off.
• You have no server to deploy to and aren’t willing to set one up.
• You need spam filtering and moderation tooling that scales.

Skip it (pick Discourse) if:

• You want a full community forum, not just a comment section.
• You need user accounts, reputation, categories, or rich moderation tools.

---

Alternatives Worth Considering

• Remark42 — the most fully-featured self-hosted commenter. Supports OAuth logins, voting, email subscriptions, multi-site, Telegram notifications. More complex to deploy, but significantly more capable. The choice for anyone who finds Isso too minimal.
• Commento — privacy-focused, self-hosted or managed SaaS. Cleaner UI than Isso, supports Disqus import, has basic spam filtering. The managed tier removes the ops burden.
• Cusdis — lightweight like Isso but with a web-based admin dashboard and email digest. Actively maintained and slightly more modern than Isso’s codebase.
• utterances / giscus — GitHub Discussions or Issues as your comment backend. Zero server to run. Trade-off: requires commenters to have a GitHub account, which filters out most non-technical audiences.
• Disqus — the incumbent. Easiest embed, largest feature set, meaningful spam filtering. Costs you your readers’ data and page load speed.
• Discourse — for when you actually want a community, not just a comment section. Heavier resource requirements (1GB RAM minimum, realistically 2GB+), but full forum capabilities.

---

Bottom Line

Isso is the right tool for a narrow but real use case: a blogger or small publisher who wants comment functionality, owns their server, and refuses to route readers through Disqus. It does that job competently, with minimal resource consumption, a genuine MIT license, and a setup process that a developer can complete in under an hour. What it isn’t is a growing, feature-rich platform — the roadmap is effectively frozen and the feature set stops at “what you need for a blog comment section.”

If your needs fit that description exactly, Isso is a good choice and you’ll have nothing to complain about. If you need spam filtering, OAuth logins, voting, or an admin dashboard, look at Remark42 or Cusdis before committing. And if the afternoon of setup is the actual blocker — that’s exactly what upready.dev deploys for clients. One-time setup, you own the infrastructure.

---

Sources

1. Quickstart — isso-comments.de — Official Isso quickstart guide covering configuration, migration, running, and integration. https://isso-comments.de/docs/guides/quickstart/
2. Getting started — isso-comments.de — Official Isso documentation intro, including the case against Disqus. https://isso-comments.de/docs/
3. chringel.dev — “Isso: an alternative commenting system for Hugo” (March 17, 2022). Practical Hugo integration walkthrough. https://chringel.dev/2022/03/isso-an-alternative-commenting-system-for-hugo/
4. Avimanyu Bandyopadhyay, Linux Handbook — “Deploying Isso Commenting System Under Nginx With Docker” (Aug 25, 2021). Full Docker Compose deployment tutorial. https://linuxhandbook.com/deploy-isso-comment/

Primary sources:

• GitHub repository and README: https://github.com/posativ/isso (5,270 stars, MIT license)
• Official website and documentation: https://isso-comments.de
• Docker image: https://github.com/isso-comments/isso/pkgs/container/isso