APIForge

Self-Hosted API Builder & Management Platform

APIForge is a Django-based platform where developers can easily create, manage, secure, and monitor APIs from a dashboard.

Home	Login	Sign Up

Dashboard	Projects	Create Project

• Authentication System: User signup, login, logout, password reset, and email verification using django-allauth
• Dashboard: Overview of all APIs, requests, API keys, and recent activity
• API Project Management: Create and organize API projects with multiple endpoints
• API Endpoint Builder: Visual endpoint creation with method, path, parameters, and documentation
• API Key System: Generate, revoke, and manage API keys with usage tracking
• Rate Limiting: Configurable rate limits per API key (requests per day)
• Analytics Dashboard: Real-time usage analytics with charts showing requests, response times, and error rates
• Automatic API Documentation: Auto-generated Swagger-like documentation for each project
• Request Logging: Detailed logs of all API requests with filtering and search
• Admin Panel: Full admin interface for managing users, projects, API keys, and usage

• Python 3.12
• Django 5
• Django REST Framework
• PostgreSQL
• Redis
• Celery

• Django Templates
• TailwindCSS
• Alpine.js
• Chart.js

• Docker & Docker Compose
• Black & Ruff (code formatting)
• pytest (testing)

1. Clone the repository

   git clone <repository-url>
   cd apiforge

2. Copy environment file

   cp .env.example .env

3. Start the services

   docker-compose up -d

4. Run migrations

   docker-compose exec django python manage.py migrate

5. Create a superuser

   docker-compose exec django python manage.py createsuperuser

6. Access the application

   • Web App: http://localhost:8000
   • Admin Panel: http://localhost:8000/admin
   • API Docs: http://localhost:8000/api/docs/

1. Create a virtual environment

   python -m venv venv
   source venv/bin/activate  # On Windows: venv\Scripts\activate

2. Install dependencies

   pip install -r requirements/development.txt

3. Install Node.js dependencies for TailwindCSS

   npm install
   npm run build:css

4. Set up environment variables

   cp .env.example .env
   # Edit .env with your configuration

5. Set up PostgreSQL and Redis

   • Create a PostgreSQL database
   • Start Redis server

6. Run migrations

   python manage.py migrate

7. Create a superuser

   python manage.py createsuperuser

8. Start the development server

   python manage.py runserver

9. Start Celery (in a separate terminal)

   celery -A config worker -l INFO

apiforge/
├── manage.py
├── config/
│   ├── settings/
│   │   ├── base.py          # Base settings
│   │   ├── development.py   # Development settings
│   │   └── production.py    # Production settings
│   ├── urls.py
│   ├── wsgi.py
│   ├── asgi.py
│   └── celery.py
├── apps/
│   ├── accounts/            # User authentication
│   ├── dashboard/           # Main dashboard
│   ├── projects/            # API projects
│   ├── apis/                # API endpoints & keys
│   └── analytics/           # Usage analytics & logs
├── templates/
│   ├── base.html
│   ├── base_dashboard.html
│   ├── components/
│   ├── account/
│   ├── dashboard/
│   ├── projects/
│   ├── apis/
│   └── analytics/
├── static/
│   └── css/
├── requirements/
├── docker-compose.yml
├── Dockerfile
└── README.md

All API requests require authentication via API key:

curl -X GET "http://localhost:8000/api/v1/products" \
  -H "Authorization: Bearer af_your_api_key_here"

API keys have configurable rate limits. Rate limit information is included in response headers:

X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 999
X-RateLimit-Reset: midnight UTC

1. Log in to the dashboard

2. Create a new project

3. Add endpoints with:

   • Name: Get All Products
   • Method: GET
   • Path: /products
   • Parameters and example responses

4. Generate an API key

5. Use the key in your applications

black .
ruff check --fix .

pytest

npm run watch:css  # Development
npm run build:css  # Production

docker-compose -f docker-compose.prod.yml up -d

1. Set DEBUG=False in environment
2. Configure proper SECRET_KEY
3. Set up PostgreSQL and Redis
4. Run with Gunicorn behind Nginx
5. Configure SSL/TLS certificates

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Submit a pull request

MIT License

For issues and questions, please open a GitHub issue.