Watch every project you ship—
for one flat price.
When you're early, you're never building just one thing. The main app. The side project. The thing you shipped last weekend at 2am. tinymon watches all of them — errors, uptime, and cron — from one dashboard, for one flat $9 a month, however many you add. Because knowing your code broke shouldn't depend on the size of your budget. Free while we're in beta.
One tool. Three jobs.
Errors
Unhandled exceptions are captured, grouped into issues by fingerprint, and shown with full stack traces and source maps. You get pinged when something new breaks — or when a fixed bug comes back.
Uptime
Point tinymon at a URL and it checks it every minute. After a couple of failures in a row it flips to down and alerts every channel you've set up — then alerts again the moment it recovers.
Cron / heartbeat
Give your nightly backup or cron job a ping URL to hit when it finishes. If a ping doesn't arrive inside its window, tinymon tells you the job missed — and tells you again when it's back on schedule.
Three lines of code. That's the setup.
The fastest way — one command (JavaScript & Next.js)
Run it in your terminal, from inside your project folder — the folder that has your package.json file. It detects your framework, installs the SDK, drops in the config, and wires up your project. Then you're capturing errors. That's the whole setup.
Or wire it in by hand — install, then call init() once
$ npm install tinymonjs import { init, captureException, setUser } from 'tinymonjs'; init({ dsn: process.env.TINYMON_DSN, environment: 'production', }); // that's it. errors auto-capture. // manual capture if you need it: setUser({ id: userId }); captureException(err);
No code. In the dashboard, open Monitors → Uptime, paste a URL, pick how often to check it. tinymon does the rest.
# nothing to install — it runs on our schedule Monitors → Uptime → https://yourapp.com/health checks every 1 min · alerts on down + recovery
Create a heartbeat to get a ping URL, then curl it at the end of your job. Miss the window and you'll hear about it.
# crontab — nightly backup at 2am 0 2 * * * /opt/backup.sh && \ curl -fsS https://console.tinymon.dev/ping/YOUR_TOKEN
One screen. Every error.
47: const profile = await getProfile(user.id); 48: if (!profile) throw new NotFoundError(); 49: return res.json(profile); at getUserHandler handlers/users.ts:47 at middleware lib/middleware.ts:23 at Router.dispatch lib/router.ts:118
The good parts. Without the bloat.
Search & filter
Full-text search across title, culprit, and exception. Filter by environment, release, level, and status; sort by most recent or most frequent.
Release tracking
Tag events with a release and tinymon shows where each error was first seen, which releases it appears in, and lets you filter the list down to one release.
Regression auto-reopen
Resolve a bug and it stays quiet — until it comes back. If the same error re-fires, tinymon reopens it, marks it regressed in <release>, and alerts you.
Alerts everywhere, on your terms
Email, Slack, Discord, or any HTTPS webhook — name each channel and write rules that decide exactly what fires (new errors, regressions, or event-count milestones), filtered by environment, level, or release, and which channels each one hits. Send email to any address you like (verified with a one-time code), flip it off, or mute a whole project for an hour during a deploy. Per-rule cooldowns and spike protection keep a bad release from blowing up your inbox. Resolved and silenced issues stay quiet.
GitHub issue linking
From an error, create a GitHub issue prefilled with the stack trace and a back-link, or paste an existing issue URL to link it. The open/closed state shows on the error.
Source maps & triage
Upload source maps to un-minify stack traces. Resolve, ignore, or silence-for-a-while on any issue. PII scrubbing and a beforeSend hook keep sensitive data out.
Made for the early days.
Enterprise tools
- Per-seat pricing. Your bill grows with your team.
- Feature depth. Distributed tracing, profiling, RUM — genuinely useful at scale.
- Enterprise-ready. SSO, SAML, audit logs, compliance certifications.
- 24/7 support contracts. For when uptime is revenue.
- Annual contracts. Procurement expects them.
- The right tool once you have a team and a budget that supports it.
tinymon
- One price. $9/month. Not per seat. Not per project.
- Three jobs, one tool. Errors, uptime, and cron/heartbeat monitoring together.
- The basics, done well. Capture, grouping, stack traces, search, releases.
- No plan tiers. Everything is in the $9 plan.
- Email, Slack, Discord & webhook alerts. New errors, regressions, downtime, missed jobs. Never noise.
- Monthly, cancel anytime. No contracts.
- The right tool until you need more — and then please go get more.
Catch it. Get pinged. Fix it.
Your app throws.
The SDK grabs the stack trace, attaches recent console.error breadcrumbs and any user/tags you've set, and ships it to tinymon. Errors are grouped into issues by fingerprint so duplicates collapse.
You get pinged.
Email or Slack, within 10 seconds. Only for new errors, or for regressions — we do the dedupe so you don't have "inbox of 400 identical notifications" syndrome.
You fix it.
Click through, read the stack trace, ship the patch, mark it resolved — and it goes quiet. If that exact error ever fires again, tinymon auto-reopens it, marks it regressed in the release it came back on, and pings you. No ceremony, no post-mortem template.
One plan. One price.
Everything, every month.
- Unlimited projects
- 50,000 errors per month
- Uptime monitors + cron/heartbeat checks
- Search, filter & release tracking
- Regression alerts (auto-reopen when a fix breaks)
- Email, Slack, Discord & webhook alerts
- GitHub issue linking
- Source maps, triage & full error history
- One flat price — no per-seat billing
- Cancel any time, no questions
Commit for a year, save $18.
- Everything in monthly
- Save $18 vs monthly
- Priority support
- First-month access
Questions you're probably about to ask.
What is tinymon, exactly?
Lightweight all-in-one monitoring for solo devs and early-stage teams. It tells you three things: when your app breaks (error tracking), when it's down (uptime checks), and when a job didn't run (cron/heartbeat monitoring) — one tool, one dashboard, $9/mo flat. The big observability platforms do all this and much more (distributed tracing, profiling, session replay) and do it well — they're just priced for teams with budgets. tinymon covers the essentials at a price that works when you're early. When you grow past it, please go use them.
What happens if I exceed 50,000 errors in a month?
First, we'll email you — you probably want to know. We'll also rate-limit and sample so you never get a surprise bill. Usually when error volume spikes, something's actually wrong: a runaway loop, a bad deploy, a regression. We'd rather help you track down what's happening than push you away over it. If it becomes a regular pattern and your real volume is just higher, reach out and we'll figure out a fair arrangement together.
How long is my data kept? Can I self-host?
We keep your error data around for as long as we reasonably can — plenty of history to spot patterns and trends. If your volume is unusually high and storage becomes a real cost on a specific account, we'll reach out before changing anything and work it out with you directly. Self-hosting is on the roadmap — when it ships, it'll be a single Docker image. No Kubernetes, no Helm, no Terraform.
Does tinymon do uptime monitoring?
Yes. Add a monitor with a URL and tinymon checks it on a schedule (every 1, 5, or 10 minutes) with a GET or HEAD request. You can require a specific status code or just accept any 2xx. After a couple of failed checks in a row (the threshold is yours, default 2) the monitor flips to down and alerts every channel you've configured; when it starts passing again you get a recovery alert. The dashboard shows recent check history and your 24-hour uptime percentage.
How do cron / heartbeat checks work?
Create a heartbeat and tinymon gives you a unique ping URL. Have your cron job, worker, or scheduled task hit that URL (a simple curl) when it finishes. You set the expected period and a grace window — if no ping arrives before last ping + period + grace, tinymon marks the job missing and alerts you. The next ping clears it and sends a recovery alert. It's the inverse of uptime: instead of us checking you, your job checks in with us.
What happens when a resolved error comes back?
When you mark an error resolved, it goes quiet — no list clutter, no alerts. But if that exact error (same fingerprint) fires again, tinymon automatically reopens it, marks it regressed in the release it returned on, and sends a regression alert through your channels. You don't have to remember to reopen anything or watch for repeats — a fix that silently breaks again won't slip past you.
Can I search and filter my errors?
Yes. There's full-text search across an issue's title, culprit, and exception type/value, plus filters for environment, release, level, and status, and sorting by most recent or most frequent. Active filters live in the URL, so a filtered view is shareable and bookmarkable.
Does it integrate with GitHub?
Yes. Connect a repository in project settings (a fine-grained Personal Access Token, stored encrypted). From any error you can create a GitHub issue prefilled with the stack trace, environment/release, and a link back to tinymon — or paste an existing issue's URL to link it. The issue's open/closed state shows on the error. A GitHub OAuth app is on the roadmap to make connecting even simpler.
What languages are supported?
JavaScript and TypeScript (Node, browser, Deno, Bun, Cloudflare Workers), Python, and Ruby are live today, with one-line middleware for Express, Fastify, Flask, Django, FastAPI, and Rails. Go and Rust are on the roadmap. Any language that can send an HTTP request can report errors via the REST API.
What does it cost?
Free while we're in beta — no card required, and billing isn't switched on yet. When we leave beta it's $9/month, flat: errors, uptime, and cron all included. No seats, no tiers, no surprise add-ons. Cancel anytime.
There's a gap in monitoring. The full-featured tools are excellent — distributed tracing, session replay, deep performance insights. But their pricing starts where most early-stage teams can't. And early on you don't need all that — you need to know when your app breaks, when it's down, and when a job didn't run, without standing up three separate products to find out.
Tinymon is built for that stage. Low cost. Honest pricing. Errors, uptime, and cron in one tool — so you catch problems before your users do, without worrying about the bill.
When you outgrow it, go use the bigger tools. They're worth it at scale. Until then, we're here to help you get there.