Login

u/ELMG006

Built an open-source outbound API gateway in Django/DRF.
▲ 1

Built an open-source outbound API gateway in Django/DRF.

​

The idea started after getting tired of re-implementing the same things every time I integrated third-party APIs:

* auth handling

* OAuth token refresh

* rate limiting

* quotas

* logging

* endpoint wrappers

* response formatting

So I built **Asstgr**: a self-hosted platform where you register external APIs once, define endpoints/params/methods, and then access everything through a unified REST interface.

Architecture is basically:

`Your App -> Asstgr -> Stripe/GitHub/OpenWeather/etc`

Features:

* OAuth2 (`client_credentials`, `authorization_code`, `password`)

* API key auth (`sk-...`)

* per-user quota system

* DRF throttling

* endpoint modeling

* audit logs

* unified `/execute/` endpoint

* response formatting modes

* Django admin support

* PostgreSQL + ASGI stack

One thing I wanted was to make external APIs behave more like internal services instead of every project having bespoke integration code.

Tech stack:

* Django 5

* Django REST Framework

* PostgreSQL

* Daphne / Channels

* SimpleJWT

It’s fully open source (MIT), and I also built a hosted SaaS version with a UI layer on top because the admin-only workflow wasn’t great for daily use.

Open source:

https://github.com/botyut/asstgr

Hosted version:

https://www.asstgr.com/home/

Would genuinely love feedback from people who’ve built internal API platforms / gateways before — especially around:

* schema design

* quota systems

* OAuth architecture

* execution abstraction

* scaling concerns

Curious if others ended up building similar internal tooling instead of using RapidAPI / Kong / Tyk / etc.

u/ELMG006 — 13 hours ago
▲ 4

Built a self-hosted outbound API gateway with Django + DRF

​

Hey everyone,

I’ve been working on a project called Asstgr: a self-hosted outbound API gateway built with Django REST Framework.

The idea is simple:

instead of integrating third-party APIs directly into every app, you register them once in Asstgr and access them through a unified REST interface.

Think of it like a private/self-hosted RapidAPI layer.

Main features:

* API registry for any external API

* Endpoint + parameter modeling

* OAuth2 support (client_credentials, authorization_code, password)

* Automatic token refresh

* API key authentication

* Per-user quota system

* DRF throttling / rate limiting

* Unified execute endpoint

* Request logging + audit trail

* Multiple response formatting modes

* Django admin back-office

Stack:

* Django 5

* Django REST Framework

* PostgreSQL

* Daphne / ASGI

* SimpleJWT

Example flow:

Your app → Asstgr → Stripe / GitHub / OpenWeather / etc.

One thing I wanted to solve:

when you manage lots of third-party integrations, auth handling, quotas, retries, logging, and normalization become repetitive very quickly.

So I tried turning that into a reusable platform.

GitHub:

https://github.com/botyut/asstgr

SaaS demo:

https://www.asstgr.com/home/

I’d love feedback from backend engineers:

* architecture

* API design

* quota/throttling strategy

* OAuth implementation

* ideas for improvement

Especially interested in opinions about whether Django is a good fit for this kind of gateway architecture long term.

reddit.com
u/ELMG006 — 3 days ago
▲ 2

In my executor, you can record the characteristics of your APIs (URLs, endpoints, methods, parameters, authentication, etc.) via the executor's API or its web interface, and then call them all using the single URL of my software's API. You can also monitor the logs of your calls and even test your APIs. For those who are curious, all the links are in my bio. Thank you for reading.

reddit.com
u/ELMG006 — 18 days ago