Skip to main content

API Generation Guide

Transform your database schema into a fully functional REST API in seconds.

Learn how Endora automatically generates production-ready APIs with authentication, validation, documentation, and testing interfaces.

🎯 What You'll Learn​

  • ✅ Automatic API generation process
  • ✅ Generated endpoint structure
  • ✅ Authentication and security
  • ✅ API testing and validation
  • ✅ Documentation generation
  • ✅ Performance optimization

📹 API Generation Overview​

🎥

From Schema to API in Seconds

Replace this entire section with your API generation overview video

Video Placeholder: Insert your API generation overview video here

See how Endora transforms your database schema into a complete REST API with all the features you need.

🚀 Understanding API Generation​

What Gets Generated?​

For each table in your schema, Endora automatically creates:

  • Complete CRUD Operations: Create, Read, Update, Delete
  • Authentication: API key-based security
  • Validation: Input validation and data sanitization
  • Documentation: Interactive Swagger UI
  • Testing Interface: Built-in API testing tools
  • Analytics: Usage monitoring and performance metrics

Generated Endpoint Structure​

POST   /table-name          # Create new record
GET    /table-name          # List all records (paginated)
GET    /table-name/{id}     # Get specific record
PUT    /table-name/{id}     # Update entire record
PATCH  /table-name/{id}     # Partial update
DELETE /table-name/{id}     # Delete record

📹 API Generation Process​

🎥

Step-by-Step API Generation

Replace this entire section with your API generation process demonstration

Video Placeholder: Insert your API generation process demo here

Watch the complete process of generating APIs from your database schema.

🚀 Generating Your API​

Step 1: Review Your Schema​

Before generating your API:

  1. Check Table Structure: Ensure all tables are properly defined
  2. Verify Relationships: Confirm foreign key relationships are correct
  3. Review Constraints: Check validation rules and data types
  4. Optimize Performance: Add indexes for frequently queried columns

Step 2: Configure API Settings​

  1. Authentication: Choose authentication method (API Key recommended)
  2. Rate Limiting: Set request limits (100/hour for free tier)
  3. CORS Settings: Configure cross-origin resource sharing
  4. Response Format: Choose JSON response structure

Step 3: Generate Endpoints​

  1. Click "Generate API": Start the automatic generation process
  2. Review Generated Endpoints: Check all created CRUD operations
  3. Configure Security: Set up authentication and permissions
  4. Test Endpoints: Use the built-in testing interface

📹 API Configuration​

🎥

Configuring Your Generated API

Replace this entire section with your API configuration demonstration

Video Placeholder: Insert your API configuration demo here

Learn how to configure authentication, rate limiting, and other API settings.

🔧 Generated API Features​

Automatic CRUD Operations​

Create (POST)​

POST /users
Content-Type: application/json
Authorization: Bearer YOUR_API_KEY

{
  "name": "John Doe",
  "email": "john@example.com",
  "age": 30
}

Read (GET)​

# Get all users
GET /users?page=1&limit=10&sort=name&order=asc

# Get specific user
GET /users/123

Update (PUT/PATCH)​

# Full update
PUT /users/123
{
  "name": "John Smith",
  "email": "john.smith@example.com",
  "age": 31
}

# Partial update
PATCH /users/123
{
  "age": 31
}

Delete (DELETE)​

DELETE /users/123

Advanced Query Features​

Pagination​

GET /users?page=2&limit=20

Sorting​

GET /users?sort=created_at&order=desc

Filtering​

GET /users?filter[status]=active&filter[age]=25
GET /users?search=john

Include Relationships​

GET /users?include=posts,comments

📹 API Testing Interface​

🎥

Testing Your Generated API

Replace this entire section with your API testing demonstration

Video Placeholder: Insert your API testing demo here

Learn how to use the built-in Swagger UI to test your API endpoints.

🧪 Testing Your API​

Built-in Swagger UI​

  1. Open Testing Interface: Click "Test API" in your project
  2. Authenticate: Enter your API key in the authorization dialog
  3. Explore Endpoints: Browse all available operations
  4. Test Requests: Send real requests and see responses
  5. View Documentation: Read detailed endpoint documentation

Testing Workflow​

1. Authentication Setup​

Authorization: Bearer YOUR_API_KEY

2. Test Create Operation​

POST /users
{
  "name": "Test User",
  "email": "test@example.com",
  "age": 25
}

3. Test Read Operations​

GET /users
GET /users/1

4. Test Update Operations​

PUT /users/1
{
  "name": "Updated User",
  "email": "updated@example.com",
  "age": 26
}

5. Test Delete Operation​

DELETE /users/1

📹 API Documentation​

🎥

Interactive API Documentation

Replace this entire section with your API documentation demonstration

Video Placeholder: Insert your API documentation demo here

See how Endora automatically generates comprehensive API documentation with examples and testing capabilities.

📚 Generated Documentation​

Automatic Documentation Features​

  • Endpoint Descriptions: Detailed information about each endpoint
  • Request/Response Examples: Sample requests and responses
  • Parameter Documentation: Complete parameter descriptions
  • Authentication Guide: How to authenticate requests
  • Error Handling: Common error codes and messages
  • Rate Limiting: Usage limits and headers

Interactive Features​

  • Try It Out: Test endpoints directly in the browser
  • Request Builder: Visual request construction
  • Response Viewer: Formatted response display
  • Error Handling: Clear error messages and solutions

🔒 Security Features​

Authentication​

  • API Key Authentication: Secure access control
  • Request Signing: Optional request signature validation
  • Rate Limiting: Prevent abuse and ensure fair usage
  • IP Whitelisting: Restrict access to specific IP addresses

Data Protection​

  • Input Validation: Automatic validation of all inputs
  • SQL Injection Prevention: Parameterized queries
  • XSS Protection: Output sanitization
  • CORS Configuration: Cross-origin request handling

📹 Security Configuration​

🎥

Securing Your Generated API

Replace this entire section with your security configuration demonstration

Video Placeholder: Insert your security configuration demo here

Learn how to configure authentication, rate limiting, and other security features.

📊 Performance Features​

Built-in Optimization​

  • Database Indexing: Automatic index creation for foreign keys
  • Query Optimization: Efficient database queries
  • Response Caching: Intelligent caching strategies
  • Connection Pooling: Optimized database connections

Monitoring and Analytics​

  • Request Tracking: Monitor API usage patterns
  • Performance Metrics: Response times and throughput
  • Error Monitoring: Track and analyze errors
  • Usage Analytics: Understand how your API is being used

📹 Performance Monitoring​

🎥

Monitoring API Performance

Replace this entire section with your performance monitoring demonstration

Video Placeholder: Insert your performance monitoring demo here

Learn how to monitor your API's performance and usage with built-in analytics.

🚀 Integration Examples​

JavaScript/Node.js​

// Fetch all users
const response = await fetch("https://api.endora.space/v1/your-project/users", {
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
});
const users = await response.json();

// Create a new user
const newUser = await fetch("https://api.endora.space/v1/your-project/users", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    name: "John Doe",
    email: "john@example.com",
    age: 30,
  }),
});

Python​

import requests

# Get all users
response = requests.get(
    'https://api.endora.space/v1/your-project/users',
    headers={'Authorization': 'Bearer YOUR_API_KEY'}
)
users = response.json()

# Create a new user
new_user = requests.post(
    'https://api.endora.space/v1/your-project/users',
    headers={'Authorization': 'Bearer YOUR_API_KEY'},
    json={
        'name': 'John Doe',
        'email': 'john@example.com',
        'age': 30
    }
)

cURL​

# Get all users
curl -X GET "https://api.endora.space/v1/your-project/users" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Create a new user
curl -X POST "https://api.endora.space/v1/your-project/users" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "John Doe", "email": "john@example.com", "age": 30}'

📹 Integration Examples​

🎥

Integrating Your API

Replace this entire section with your integration examples demonstration

Video Placeholder: Insert your integration examples demo here

See how to integrate your generated API with various programming languages and frameworks.

🎯 Best Practices​

API Design​

Use RESTful Conventions

Follow REST principles for consistent, predictable APIs

Implement Proper Error Handling

Return meaningful error messages with appropriate HTTP status codes

Add Request Validation

Validate all inputs to ensure data quality and security

Document Everything

Provide comprehensive documentation for all endpoints

Performance Optimization​

Use Pagination

Implement pagination for large datasets to improve performance

Add Caching

Use caching strategies to reduce database load

Monitor Performance

Track API performance and optimize based on usage patterns

Scale Horizontally

Design for horizontal scaling as your API grows

🚀 Next Steps​

Your API is Ready!​

After generating your API:

  1. Test All Endpoints: Verify functionality using Swagger UI
  2. Configure Security: Set up authentication and rate limiting
  3. Monitor Usage: Track performance and usage patterns
  4. Integrate: Start using your API in applications

Learn More​

Advanced Features​

Ready to deploy your API? Learn about deployment → 🚀