I use a Slack workspace built with Django and DRF where I put all my functions and classes to call and manage different types of APIs, and then I just have to go through this Slack workspace to call my different APIs. What about you?
I use a proxy that I developed myself, and it's this proxy that handles executing the APIs on other servers. All I have to do is register the different APIs and their characteristics in my proxy (URLs, endpoint, method, parameter type, etc.). Then, all I have to do is integrate my proxy's API into my code, specify which API, how, and which part of the API I want to call to my proxy, and choose the same response format for all my APIs. Then, my proxy handles reconstructing and executing the requests on its servers using the API data I've registered, retrieving the responses, cleaning them, and formatting them before sending them back to my project. I'm curious to see what you use or have developed for this type of problem in particular.
​
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:
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.
​
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:
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.
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.