Self-hosted service
usesend/useSend avatar
usesend/useSend

useSend: the open source Resend alternative that still hands the mail to Amazon SES

Open source alternative to Resend, Sendgrid, Postmark etc.

4,807 stars448 forksTypeScriptAGPL-3.0

At a glance

What is it?
useSend gives you the dashboard, API, SMTP server and marketing tools of a hosted email platform in a repository you can run yourself, while the actual delivery still goes through Amazon SES and two feature boxes, inbound email and your own AWS credentials, are still empty.
Who is it for?
Adopt useSend if you want the whole email stack, dashboard, queue, editor and SMTP server under your own control and you are already willing to deal with Amazon SES. Do not adopt it expecting independence from AWS, because delivery runs through SES and the bring your own AWS credentials box is still unchecked.
Can I use it commercially?
Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly TypeScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • usesend/useSend4,807 ★ · +114
Star history
Repository2026-09-232026-11-15
usesend/useSend4.7k4.8k

114 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The open alternative still sends through Amazon SES

The repository calls itself an open source alternative to Resend, SendGrid and Postmark, and then says something worth pausing on: as most email products out there, useSend also uses Amazon SES under the hood to send emails.

So what you get by self-hosting is the application around the provider. The dashboard, the REST API, the SMTP server, the queue, the contact list and the marketing send are all in this repository. The hop that actually accepts your mail and talks to receiving servers is still SES.

That is a deliberate trade rather than an oversight, and it is the trade most open alternatives to hosted email make. Deliverability lives in the provider's reputation, and reputation is not something you can stand up in a Docker container. The README's pitch is about control of the dashboard and the cost of the software layer, not about escaping the upstream.

Beyond transactional mail, useSend also manages contacts and bulk sends such as newsletters and product updates, and says it takes care of the subscriptions.

Two unchecked boxes: inbound email and your own AWS credentials

The feature list is a checklist with two boxes still empty. Everything else is ticked: add domains, transactional mails, REST API, a dashboard covering delivered, opened, clicked and bounced, marketing email, SMTP support, a schedule API and webhook support.

The two that are not done are inbound email and BYO AWS credentials.

Inbound being absent is straightforward: you can send from useSend and you cannot receive into it. If you are planning to handle replies in the same tool, that is not in this release.

BYO AWS credentials is the one that shapes your deployment. While that box is empty, running your own instance still means supplying AWS credentials in your own environment. The example environment file shows what that looks like in practice, with AWS_DEFAULT_REGION, AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY set to placeholder values.

hono is the public API, tRPC is the one inside

The tech stack list is short and the two API layers are named separately: tRPC for the API and hono for the public API.

That split matters if you are integrating. hono is the HTTP framework serving the public surface, the one your applications call, and tRPC is the typed layer the dashboard and the application's own front end use. Next.js is the framework, Prisma the ORM, Tailwind and shadcn/ui the styling and component layer, NextAuth.js the authentication, and Redis the queue.

Redis as the queue is the load-bearing choice in that list. Sends, schedules and webhooks are work that outlives a request, and putting Redis in front of them means a Redis instance you operate is part of the send path. The example environment file confirms it: REDIS_URL points at localhost:6379, with an optional REDIS_KEY_PREFIX and a comment explaining that it is useful on a shared Redis with ACL isolation.

That last detail is the one to notice if you are not running a dedicated Redis: the prefix exists so several instances can share one.

The editor is tiptap, rendered through jsx-email

useSend has its own email editor, and the README points at packages/email-editor for the code. Three libraries do the work, and their order describes the pipeline.

tiptap is the editor core. maily.to is what the interface is inspired by, with the README saying the editor is greatly inspired from maily.to. jsx-email is the part that converts editor content to html, which is how a rich text document becomes an email body rather than a web page.

For a deployment that matters mostly in that editor package exists as a workspace package with its own build target: package.json has build:editor running turbo with a filter for @usesend/email-editor, and the wider builds each filter for that package plus web or marketing.

The web and marketing build scripts both include the editor package, so it is built alongside either app.

Local development points SES at localhost:3003

The example environment file is the most informative document for a self-hoster, because it shows what has to be provided rather than what is built in. Four lines set the shape of local development:

text
DATABASE_URL="postgresql://usesend:password@localhost:54320/usesend"
REDIS_URL="redis://localhost:6379"
AWS_SES_ENDPOINT="http://localhost:3003/api/ses"
AWS_SNS_ENDPOINT="http://localhost:3003/api/sns"

The two AWS endpoints point at a local service on port 3003 rather than at AWS, which is how the project lets you develop without sending real mail or holding real credentials. The PostgreSQL port is 54320, not the default, so the local database is expected to come from the project's own compose setup rather than a system install.

Two values are worth arguing with before production. API_RATE_LIMIT is set to 2 and AUTH_EMAIL_RATE_LIMIT to 5, which are development numbers. And NEXT_PUBLIC_IS_CLOUD is true in the example, which is a flag the self-hosted build will want set the other way.

Tests bring up a compose file and tear it down with -v

The script list shows how integration testing is wired, and it is worth reading because the pattern is unusual. Two scripts own the infrastructure:

json
"test:infra:up": "docker compose -f docker/testing/compose.yml up -d --wait",
"test:infra:down": "docker compose -f docker/testing/compose.yml down -v",

They point at docker/testing/compose.yml, they run detached with --wait so the services are healthy before a test starts, and the teardown passes -v, which removes the volumes as well as the containers.

The full test script wraps both around the actual suite, capturing the exit code, running the teardown anyway and re-throwing the code, so a failed test still cleans up its infrastructure. There are narrower scripts too, for unit tests, tRPC, API and integration tests, each filtered to the web workspace.

Two things follow for a contributor. The tests need Docker and a compose file rather than a mocked database, and the file lives under docker/testing rather than at the root, so it is found by an exact relative path.

The repository ships four AI agent configuration directories

The root of this repository contains .claude/, .codex/, .cursor/ and .opencode/ as directories, alongside AGENTS.md and a .entire/ directory.

Four agent configuration directories in one tree suggest the project is worked on with several AI coding tools. .entire/ sits with them, and AGENTS.md is the plain-text version for anything that reads a repository-level instruction file.

The rest of the root is a pnpm and turbo monorepo. pnpm-workspace.yaml and pnpm-lock.yaml for the package graph, turbo.json for the task graph that build, lint and dev all delegate to, nixpacks.toml for deployment builds, .eslintrc.js for linting, .npmrc, tsconfig.json, and two environment examples in .env.example and .env.selfhost.example.

Those two environment files are the clearest hint about what self-hosting costs you: the self-hosting variant is maintained separately from the development one, which is what you would expect from a project whose deployment is the product.

Beta, with a first source release and a call for issues

The project says it is currently in beta, and the community section repeats that the team is working on opening useSend for public beta. The list of next steps is unusually direct: check out the first source code release in the repository and test it, say what you think in Discussions, join the Discord server, fix or create the issues that are needed for the first production release.

Deployment is offered three ways. A container is published on both DockerHub and the GitHub Container Registry at ghcr.io/usesend/usesend, with the reminder that you must provide environment variables for the database, Redis, AWS and so forth, and a Docker README in the docker directory. Self-hosting has its own guide at docs.usesend.com/self-hosting/overview, and Railway is called the quickest path with its own guide and a deploy button.

The licence is AGPL-3.0, which is the one to read carefully if you intend to run a hosted version for other people. The sponsor list at the bottom includes CodeRabbit at the top, one bronze sponsor and a few others, and the star history chart is embedded above them.

Editorial conclusion

Adopt useSend if you want the whole email stack, dashboard, queue, editor and SMTP server under your own control and you are already willing to deal with Amazon SES. Do not adopt it expecting independence from AWS, because delivery runs through SES and the bring your own AWS credentials box is still unchecked. Two things to verify before you plan a deployment: which licence obligations AGPL-3.0 puts on a hosted version you expose to other people, and whether your sender reputation plan accounts for SES, since self-hosting moves the application and not the deliverability.

Frequently asked questions

What are some free alternatives to Resend?

useSend describes itself as an open source alternative to Resend, SendGrid and Postmark. It is AGPL-3.0 licensed and self-hostable, with a dashboard, REST API, SMTP support and webhooks, and like most products in that category it delivers through Amazon SES under the hood.

Is useSend ready for production?

The README states that useSend is currently in beta and that the team is working on opening it for public beta. Inbound email and bringing your own AWS credentials are the two unchecked items on the feature list.

How do I self-host useSend?

With the published container on DockerHub or the GitHub Container Registry at ghcr.io/usesend/usesend, supplying environment variables for the database, Redis and AWS. There is also a self-hosting guide at docs.usesend.com/self-hosting/overview and a Railway guide with a deploy button.

Which database and queue does useSend use?

PostgreSQL through Prisma, and Redis as the queue. The example environment file sets DATABASE_URL to a local PostgreSQL on port 54320 and REDIS_URL to redis://localhost:6379, with an optional REDIS_KEY_PREFIX for sharing one Redis across instances.

What APIs does useSend expose?

Two, by its own stack list: tRPC for the API used inside the application and hono for the public API. The feature list also names a REST API, an SMTP server, a schedule API and webhook support.

Official sources

  1. License: AGPL-3.0
  2. Project website
  3. README
  4. Releases
  5. usesend/useSend on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/usesend-usesend.svg)](https://hysenlabs.com/projects/usesend-usesend)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/usesend-usesend.svg)](https://hysenlabs.com/projects/usesend-usesend)

Was this useful?