# Api endpoints
Source: https://doc.eazemyapi.com/docs/api-endpoints



EazeMyAPI automatically generates REST API endpoints for every table created in your project.
These endpoints allow your applications to perform standard **CRUD operations**:

* Create data
* Read data
* Update data
* Delete data

No backend server code is required.

***

# Endpoint Structure

All EazeMyAPI endpoints follow a consistent structure.

```
https://api.eazemyapi.com/{project-name}/{table}/{version}/{action}
```

Example:

```
https://api.eazemyapi.com/my-project/users/v1/list
```

Components:

| Part                | Description                                  |
| ------------------- | -------------------------------------------- |
| `api.eazemyapi.com` | API server                                   |
| `{project-name}`    | Your project identifier                      |
| `{table}`           | The table name                               |
| `{version}`         | API version (e.g. `v1`, `v2`)                |
| `{action}`          | API action (e.g. `list`, `create`, `delete`) |

***

# Common Endpoint Types

When you create a table, EazeMyAPI automatically generates endpoints for common operations.

***

## List

Retrieve all records from a table.

```
GET https://api.eazemyapi.com/{project-name}/{table}/{version}/list
```

Example request:

```bash theme={null}
curl -X GET https://api.eazemyapi.com/my-project/users/v1/list \
  -H "X-API-SIGNATURE: your-secret-key"
```

Example response:

```json theme={null}
{
  "success": true,
  "message": "Data found.",
  "data": [
    {
      "id": 1,
      "name": "Dara Singh",
      "email": "dara@example.com"
    }
  ]
}
```

***

## Show

Retrieve a single record by ID.

```
GET https://api.eazemyapi.com/{project-name}/{table}/{version}/show/:id
```

Example request:

```bash theme={null}
curl -X GET https://api.eazemyapi.com/my-project/users/v1/show/1 \
  -H "X-API-SIGNATURE: your-secret-key"
```

Example response:

```json theme={null}
{
  "success": true,
  "message": "Data found.",
  "data": {
    "id": 1,
    "name": "Dara Singh",
    "email": "dara@example.com"
  }
}
```

***

## Create

Create a new record in a table.

```
POST https://api.eazemyapi.com/{project-name}/{table}/{version}/create
```

Example request:

```bash theme={null}
curl -X POST https://api.eazemyapi.com/my-project/users/v1/create \
  -H "Content-Type: application/json" \
  -H "X-API-SIGNATURE: your-secret-key" \
  -d '{
    "name": "Dara Singh",
    "email": "dara@example.com"
  }'
```

Example response:

```json theme={null}
{
  "success": true,
  "message": "Record created successfully.",
  "data": {
    "id": 1,
    "name": "Dara Singh",
    "email": "dara@example.com"
  }
}
```

***

## Update

Update an existing record by ID.

```
POST https://api.eazemyapi.com/{project-name}/{table}/{version}/update/:id
```

Example request:

```bash theme={null}
curl -X POST https://api.eazemyapi.com/my-project/users/v1/update/1 \
  -H "Content-Type: application/json" \
  -H "X-API-SIGNATURE: your-secret-key" \
  -d '{
    "name": "Dara Singh"
  }'
```

Example response:

```json theme={null}
{
  "success": true,
  "message": "Record updated successfully.",
  "data": {
    "id": 1,
    "name": "Dara Singh",
    "email": "dara@example.com"
  }
}
```

***

## Delete

Delete a record by ID.

```
DELETE https://api.eazemyapi.com/{project-name}/{table}/{version}/delete/:id
```

Example request:

```bash theme={null}
curl -X DELETE https://api.eazemyapi.com/my-project/users/v1/delete/1 \
  -H "X-API-SIGNATURE: your-secret-key"
```

Example response:

```json theme={null}
{
  "success": true,
  "message": "Record deleted successfully."
}
```

***

# Custom Endpoints

EazeMyAPI also supports **raw custom query endpoints** for more advanced use cases. Unlike CRUD endpoints, custom queries are not tied to a specific table — so there is no `{table}` segment in the URL.

```
https://api.eazemyapi.com/{project-name}/{version}/{custom-endpoint}
```

Example request:

```bash theme={null}
curl https://api.eazemyapi.com/my-project/v1/posts-by-category \
  -H "X-API-SIGNATURE: your-secret-key"
```

Example response:

```json theme={null}
{
  "success": true,
  "message": "Data found.",
  "data": [
    {
      "category_id": "c40a4731-a541-4d2b-af77-326af7142aab",
      "category_name": "Foods",
      "post_id": "2529c967-33a3-4f7b-aabd-84e90f861e14",
      "description": "Best restaurant in the world"
    }
  ]
}
```

***

# Best Practices

When using EazeMyAPI endpoints:

* Always include the **`X-API-SIGNATURE` header**
* Validate request parameters before sending
* Handle error responses properly
* Use HTTPS for all API requests

***

# Related Documentation

Learn how authentication works:

[Authentication](/docs/authentication)

Understand response structure:

[API Response Format](/docs/response-format)


# Api quick start
Source: https://doc.eazemyapi.com/docs/api-quick-start



This guide shows how to start using **EazeMyAPI APIs in less than 5 minutes**.
You will learn how to:

* Create a project
* Generate APIs
* Call APIs from your application

***

# Step 1 — Create a Project

Login to your dashboard.

Open:

```
Dashboard → Create Project
```

Enter your project name.

Example:

```
my-project
```

Each project has its own database and APIs.

***

# Step 2 — Create a Table

Inside your project, create a table.

Example table:

```
users
```

Add fields:

```
id
name
email
created_at
```

Save the table.

EazeMyAPI will automatically generate APIs for this table.

***

# Step 3 — Get Your API Secret Key

Every API request requires your **API Signature Key**.

You can find it here:

```
Project → Settings → API Signature Key
```

Example:

```
X-API-SIGNATURE: your-secret-key
```

Keep this key secure.

***

# Step 4 — Call Your First API

Example request to fetch all users.

```
GET https://api.eazemyapi.com/{project-name}/{table}/{version}/list
```

### JavaScript Example

```javascript theme={null}
fetch("https://api.eazemyapi.com/my-project/users/v1/list", {
  method: "GET",
  headers: {
    "Content-Type": "application/json",
    "X-API-SIGNATURE": "your-secret-key"
  }
})
.then(response => response.json())
.then(data => {
  console.log(data);
});
```

This request retrieves all records from the **users** table.

***

# Step 5 — Create a Record

Example request to create a new user.

```
POST https://api.eazemyapi.com/{project-name}/{table}/{version}/create
```

```javascript theme={null}
fetch("https://api.eazemyapi.com/my-project/users/v1/create", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "X-API-SIGNATURE": "your-secret-key"
  },
  body: JSON.stringify({
    name: "Dara Singh",
    email: "dara@example.com"
  })
})
.then(response => response.json())
.then(data => {
  console.log(data);
});
```

This creates a new user in the database.

***

# Example Using cURL

You can also test APIs using cURL or Postman.

```bash theme={null}
curl -X GET https://api.eazemyapi.com/my-project/users/v1/list \
  -H "X-API-SIGNATURE: your-secret-key"
```

***

# What Happens Next?

After connecting your API, you can:

* Integrate with React or Next.js
* Build mobile apps
* Create SaaS products
* Launch MVP backends quickly

***

# Recommended Next Steps

Continue reading the documentation:

## Documentation

* [Getting Started](docs/getting-started)
  Learn how to create your first backend project.
* [Creating Tables](docs/create-tables)
  Define database tables and structure your data.
* [Authentication](docs/authentication)
  Secure your APIs using the API signature key.
* [Custom Queries](docs/custom-queries)
  Execute advanced queries and build complex logic.
* [Frontend Integration](docs/frontend-integration)
  Connect EazeMyAPI APIs with React, Flutter, or mobile apps.

These guides will help you build a complete backend with EazeMyAPI.


# Api reference
Source: https://doc.eazemyapi.com/docs/api-reference



This document describes how to interact with **EazeMyAPI generated APIs**.
EazeMyAPI automatically generates REST APIs for each database table in your project.
Describe your app → AI creates database → APIs ready instantly.

Guide:
[Getting Started](getting-started)

***

# Base API URL

All API requests follow this format:

```
https://api.eazemyapi.com/{project-name}/{table}/{version}/{action}
```

Example:

```
https://api.eazemyapi.com/my-project/users/v1/list
```

***

# Authentication

Every request must include the API signature header.

```
X-API-SIGNATURE: <your-secret-key>
```

You can find your key here:

```
Project → Settings → API Signature Key
```

Full guide:
[Authentication](authentication)

***

# API Endpoints

For each table, EazeMyAPI automatically generates REST endpoints.

Example table:

```
users
```

Generated endpoints:

| Method | Endpoint                                       | Description              |
| ------ | ---------------------------------------------- | ------------------------ |
| GET    | `/{project-name}/{table}/{version}/list`       | Retrieve all records     |
| GET    | `/{project-name}/{table}/{version}/show/:id`   | Retrieve a single record |
| POST   | `/{project-name}/{table}/{version}/create`     | Create a new record      |
| POST   | `/{project-name}/{table}/{version}/update/:id` | Update a record          |
| DELETE | `/{project-name}/{table}/{version}/delete/:id` | Delete a record          |

Guide:
[Generating APIs](generate-api)

***

# Example Requests

### List Records

```javascript theme={null}
fetch("https://api.eazemyapi.com/my-project/users/v1/list", {
  method: "GET",
  headers: {
    "X-API-SIGNATURE": "your-secret-key"
  }
})
```

***

### Show Record

```javascript theme={null}
fetch("https://api.eazemyapi.com/my-project/users/v1/show/1", {
  method: "GET",
  headers: {
    "X-API-SIGNATURE": "your-secret-key"
  }
})
```

***

### Create Record

```javascript theme={null}
fetch("https://api.eazemyapi.com/my-project/users/v1/create", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "X-API-SIGNATURE": "your-secret-key"
  },
  body: JSON.stringify({
    name: "Dara Singh",
    email: "dara@example.com"
  })
})
```

***

### Update Record

```javascript theme={null}
fetch("https://api.eazemyapi.com/my-project/users/v1/update/1", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "X-API-SIGNATURE": "your-secret-key"
  },
  body: JSON.stringify({
    name: "Dara Singh Updated"
  })
})
```

***

### Delete Record

```javascript theme={null}
fetch("https://api.eazemyapi.com/my-project/users/v1/delete/1", {
  method: "DELETE",
  headers: {
    "X-API-SIGNATURE": "your-secret-key"
  }
})
```

***

# Response Format

All APIs return JSON responses.

Example:

```json theme={null}
{
  "success": true,
  "message": "Data found.",
  "data": {
    "id": 1,
    "name": "Dara Singh",
    "email": "dara@example.com"
  }
}
```

***

# Next Steps

Learn more about using EazeMyAPI:

* [Creating Tables](create-tables)
* [Generating APIs](generate-api)
* [Frontend Integration](frontend-integration)


# Api url structure
Source: https://doc.eazemyapi.com/docs/api-url-structure



# EazeMyAPI URL Structure

All EazeMyAPI endpoints follow a consistent URL structure.

```
https://api.eazemyapi.com/{project}/{table}/{version}/{action}
```

Each part of the URL defines how the API request is routed.

***

## URL Components

| Component           | Description                                   |
| ------------------- | --------------------------------------------- |
| `api.eazemyapi.com` | Base API server                               |
| `{project}`         | Your project identifier                       |
| `{table}`           | Database table name                           |
| `{version}`         | API version (v1, v2, etc.)                    |
| `{action}`          | CRUD operation (list, create, update, delete) |

***

## Example API URL

```
https://api.eazemyapi.com/demo-project/users/v1/list
```

In this example:

| Part    | Value        |
| ------- | ------------ |
| project | demo-project |
| table   | users        |
| version | v1           |
| action  | list         |

***

## CRUD API Structure

EazeMyAPI automatically generates standard CRUD APIs for every table.

| Operation     | Method | Endpoint                                   |
| ------------- | ------ | ------------------------------------------ |
| List Records  | GET    | `/{project}/{table}/{version}/list`        |
| Create Record | POST   | `/{project}/{table}/{version}/create`      |
| Update Record | POST   | `/{project}/{table}/{version}/update/{id}` |
| Delete Record | DELETE | `/{project}/{table}/{version}/delete/{id}` |

***

## API Request Example

### cURL Example

```bash theme={null}
curl "https://api.eazemyapi.com/demo-project/users/v1/list" \
  -H "X-API-SIGNATURE: your-secret-key"
```

***

## Example Response

```json theme={null}
{
  "success": true,
  "message": "Data found.",
  "data": [
    {
      "id": 1,
      "name": "Dara Singh",
      "email": "dara@eazemyapi.com"
    }
  ]
}
```

***

## API Versioning

EazeMyAPI uses **versioned APIs** to ensure backward compatibility.

### Example Versions

```
v1
v2
v3
```

### Example

```
https://api.eazemyapi.com/demo-project/users/v2/list
```

Versioning allows your application to continue working even when new features are added.

***

## Endpoint Naming Convention

Endpoints in EazeMyAPI follow a simple and predictable CRUD-based structure.

| Action        | Description            |
| ------------- | ---------------------- |
| `list`        | Fetch all records      |
| `create`      | Create new record      |
| `update/{id}` | Update existing record |
| `delete/{id}` | Delete record by ID    |

These APIs are automatically generated based on your database tables.

***

## Authentication Header

Every request must include the API signature header.

```
X-API-SIGNATURE: your-secret-key
```

Learn more about authentication:

[Authentication](/docs/authentication)

***

## Best Practices

When building API requests:

* Always include the **API signature header**

* Use the correct **table name in URL**

* Validate request parameters

* Use HTTPS for secure communication

***

## Related Documentation

Learn how APIs are generated automatically:

[Generate API](/docs/generate-api)

Explore available endpoints:

[API Endpoints](/docs/api-endpoints)


# Authentication
Source: https://doc.eazemyapi.com/docs/authentication



All API requests to **EazeMyAPI** must include an authentication header.

This ensures that only authorized applications can access your project APIs.

EazeMyAPI uses a **project-level API signature key** to verify requests.

***

## API Signature Header

Every API request must include the following header:

```
X-API-SIGNATURE: <your-secret-key>
```

This key identifies your project and authorizes the request.

***

## Where to Find Your API Key

You can find your API signature key inside your project settings.

### Steps

1. Open your **Project**
2. Go to **Settings**
3. Copy the **API Signature Key**

### Location in Dashboard

```
Project → Settings → API Signature Key
```

Keep this key secure. Do not expose it publicly.

***

## Example API Request

```
https://api.eazemyapi.com/demo-project/users/v1/list
```

### JavaScript Example

```javascript theme={null}
fetch("https://api.eazemyapi.com/demo-project/users/v1/list", {
  method: "GET",
  headers: {
    "Content-Type": "application/json",
    "X-API-SIGNATURE": "your-secret-key"
  }
})
.then(response => response.json())
.then(data => {
  console.log(data);
});
```

***

## Example Using cURL

```bash theme={null}
curl https://api.eazemyapi.com/demo-project/users/v1/list \
  -H "X-API-SIGNATURE: your-secret-key"
```

***

## Example Using Postman

When testing APIs in **Postman**:

1. Open Postman
2. Create a new request
3. Go to the **Headers** tab
4. Add the following header

```
Key: X-API-SIGNATURE
Value: your-secret-key
```

Then send the request.

***

## Security Best Practices

Follow these guidelines to protect your API key:

* Never expose your secret key in public repositories
* Avoid placing secret keys directly inside frontend code
* Store API keys in environment variables
* Rotate keys if you suspect unauthorized access

***

## Important Note

The API signature key gives access to your project APIs.

Anyone who has this key can send requests to your backend.

Always handle it securely and avoid sharing it publicly.

***

## Next Step

Once authentication is configured, you can start executing advanced database operations.

Continue to:

[Writing Custom Queries](/docs/custom-queries)


# Create project
Source: https://doc.eazemyapi.com/docs/create-project



A **Project** in EazeMyAPI is the main workspace where you build your backend.

Each project contains:

* Database tables
* Automatically generated APIs
* API authentication settings
* Project-level configurations

You can create multiple projects to manage different applications.

***

## Step 1 — Login to Dashboard

Go to the EazeMyAPI dashboard:

```
https://eazemyapi.com
```

Sign in using your account.

After login, you will see the **Projects Dashboard**.

***

## Step 2 — Create a New Project

Click the **Create Project** button.

Enter the following details:

* **Project Name** – Name of your application backend
* **Description (optional)** – Short description of the project

### Example

```
Project Name: MyStartupApp
Description: Backend for my MVP mobile app
```

Click **Create** to continue.

***

## Step 3 — Project Environment Ready

Once the project is created, EazeMyAPI automatically prepares the backend environment.

Your project now includes:

* Database system
* API generation engine
* API authentication system
* Project configuration settings

You are now ready to start building your backend.

***

## Step 4 — Open the Project Dashboard

Click your project from the project list.

Inside the project dashboard you will see options like:

* Tables
* APIs
* Queries
* Settings

This is where you will manage your backend structure.

***

## Next Step

Now that your project is ready, the next step is to create database tables.

Continue to the next guide:

[Creating Tables](create-tables)


# Create tables
Source: https://doc.eazemyapi.com/docs/create-tables



Tables are the foundation of your backend.

Each table represents a collection of structured data used by your application.

### Common Examples

* Users
* Products
* Orders
* Messages

***

## How to Create a Table

Follow these steps to create a new table:

1. Open your **Project Dashboard**
2. Click **Create Table**
3. Enter a **Table Name**
4. Add required **Fields (Columns)**
5. Click **Save**

***

## Example: Users Table

Below is a simple example of a Users table structure:

| Field       | Type        | Description          |
| ----------- | ----------- | -------------------- |
| id          | Primary Key | Unique identifier    |
| name        | Text        | User name            |
| email       | Text        | User email           |
| password    | Text        | Encrypted password   |
| created\_at | Datetime    | Record creation time |

***

## What Happens After Creating a Table?

Once your table is saved, EazeMyAPI automatically:

* Generates CRUD APIs
* Connects APIs to your database
* Enables authentication for requests
* Prepares your backend instantly

You can immediately start using APIs for this table.

***

## Best Practices

Follow these guidelines for better backend design:

* Use clear and meaningful table names (e.g., `users`, `orders`)
* Keep field names simple and consistent
* Avoid unnecessary or duplicate columns
* Use proper data types for each field
* Plan relationships between tables early (e.g., user\_id in orders)

***

## Next Step

Now that your table is ready, you can start using APIs generated for it.

Continue to:

[Using APIs](api-endpoints)


# Custom queries
Source: https://doc.eazemyapi.com/docs/custom-queries



EazeMyAPI allows you to write **custom database queries** and expose them as API endpoints.

This feature is useful when you need more control than the automatically generated CRUD APIs.

With custom queries you can:

* Join multiple tables
* Filter complex data
* Create custom reports
* Build advanced API endpoints

***

## When to Use Custom Queries

Use custom queries when:

* You need **JOIN operations**
* You want **custom filters**
* You need **aggregated data**
* You want **custom endpoints for frontend apps**

### Example Use Cases

* Fetch posts by category
* Get user statistics
* Build dashboard analytics
* Filter records by multiple conditions

***

## Example Query

Example query that retrieves posts by category:

```sql theme={null}
SELECT 
  categories.id AS category_id,
  categories.name AS category_name,
  posts.id AS post_id,
  posts.description
FROM categories
JOIN posts ON posts.category_id = categories.id
WHERE categories.name = '{category_name}';
```

***

## Generated API Endpoint

Once a custom query is saved, EazeMyAPI automatically generates an API endpoint.

```
https://api.eazemyapi.com/{project}/{version}/{query-name}
```

### Example

```
https://api.eazemyapi.com/demo-project/v1/posts-by-category
```

***

## Example API Request

```bash theme={null}
curl https://api.eazemyapi.com/demo-project/v1/posts-by-category \
  -H "X-API-SIGNATURE: your-secret-key"
```

***

## Example API Response

```json theme={null}
{
  "success": true,
  "message": "Data found.",
  "data": [
    {
      "category_id": "c40a4731-a541-4d2b-af77-326af7142aab",
      "category_name": "Foods",
      "post_id": "2529c967-33a3-4f7b-aabd-84e90f861e14",
      "description": "Best restaurant in the world"
    },
    {
      "category_id": "c40a4731-a541-4d2b-af77-326af7142aab",
      "category_name": "Foods",
      "post_id": "5f8b35c8-372c-4ab2-9c01-569085f05a72",
      "description": "Best restaurant in Ahmedabad"
    }
  ]
}
```

***

## Creating a Custom Query

To create a custom query in the dashboard:

1. Open your **Project**
2. Navigate to **Queries** or **Custom Queries**
3. Click **Create Query**
4. Write your SQL query
5. Save the query

Once saved, an API endpoint will automatically be generated.

***

## Query Parameters

Custom queries can accept parameters.

### Example Query

```sql theme={null}
SELECT *
FROM posts
WHERE category_id = '{category_id}';
```

### Example API Request

```
https://api.eazemyapi.com/demo-project/v1/posts-by-category?category_id=c40a4731-a541-4d2b-af77-326af7142aab
```

***

## Best Practices

When writing custom queries:

* Keep queries optimized
* Use indexes when possible
* Avoid returning unnecessary columns
* Validate input parameters
* Use parameter binding (avoid raw string injection)

Well-written queries improve API performance and security.

***

## Related Documentation

Learn how database tables work:

[Database Schema](/docs/database-schema)

Understand API endpoints:

[API Endpoints](/docs/api-endpoints)


# Database schema
Source: https://doc.eazemyapi.com/docs/database-schema



# Database Schema in EazeMyAPI

In EazeMyAPI, your backend is structured using **database tables**.
Each table represents a collection of related data and automatically generates APIs for interacting with that data.

Instead of manually coding backend endpoints, you simply define your **database schema**, and EazeMyAPI generates the API automatically.

***

## What is a Database Schema?

A **database schema** defines how your data is structured.

It includes:

* Tables
* Fields
* Field types
* Relationships between tables

### Example Schema (Users Table)

| Field       | Type      |
| ----------- | --------- |
| id          | NUMBER    |
| name        | TEXT      |
| email       | EMAIL     |
| phone       | PHONE     |
| bio         | PARAGRAPH |
| is\_active  | BOOLEAN   |
| created\_at | DATETIME  |

***

## Example Record

Example data stored in the **users** table:

```json theme={null}
{
  "id": 1,
  "name": "Dara Singh",
  "email": "dara@example.com",
  "phone": "+91 9876543210",
  "bio": "Founder",
  "is_active": true,
  "created_at": "2026-03-10T10:30:00Z"
}
```

***

## Automatic API Generation

Once a table is created, EazeMyAPI automatically generates APIs for it.

### Generated Endpoints (users table)

```
GET    /{project}/users/{version}/list
POST   /{project}/users/{version}/create
POST   /{project}/users/{version}/update/{id}
DELETE /{project}/users/{version}/delete/{id}
```

These APIs allow you to perform standard **CRUD operations**.

* Create data
* Read data
* Update data
* Delete data

***

## Example API Endpoint

```
https://api.eazemyapi.com/demo-project/users/v1/list
```

### Example Request

```bash theme={null}
curl https://api.eazemyapi.com/demo-project/users/v1/list \
  -H "X-API-SIGNATURE: your-secret-key"
```

***

## Multiple Tables Example

### Users Table

| Field       | Type     |
| ----------- | -------- |
| id          | NUMBER   |
| name        | TEXT     |
| email       | EMAIL    |
| created\_at | DATETIME |

### Posts Table

| Field       | Type      |
| ----------- | --------- |
| id          | NUMBER    |
| title       | TEXT      |
| content     | PARAGRAPH |
| user\_id    | NUMBER    |
| created\_at | DATETIME  |

***

## Table Relationships

Tables can be connected using **relationships**.

### Example

```
users
  ↓
posts
```

```
posts.user_id → users.id
```

This means each post belongs to a specific user.

***

## Best Practices for Schema Design

When designing database tables in EazeMyAPI:

* Keep each table focused on one type of data
* Use clear and descriptive field names
* Use proper field types for validation
* Create relationships when data is connected

A well-designed schema makes your backend **easier to maintain and scale**.

***

## Related Documentation

Learn about supported field types:

[Field Types](/docs/field-types)

***

## Next Step

Now learn how APIs are generated automatically.

[How EazeMyAPI Works](/docs/how-eazemyapi-works)


# Field types
Source: https://doc.eazemyapi.com/docs/field-types



When creating tables in EazeMyAPI, each field must have a **data type**.
The data type defines what kind of data the field can store.

Choosing the correct field type ensures:

* Better data validation
* Efficient database queries
* Accurate API responses

***

## Supported Field Types

EazeMyAPI supports the following field types.

***

## TEXT

The **TEXT** type stores short text values.

Common uses:

* names
* titles
* usernames
* city names

Example:

```
name: "Dara Singh"
```

Example API response:

```json theme={null}
{
  "name": "Dara Singh"
}
```

***

## NUMBER

The **NUMBER** type stores integer numbers.

Common uses:

* age
* quantity
* counts
* IDs

Example:

```
age: 38
```

Example API response:

```json theme={null}
{
  "age": 38
}
```

***

## PARAGRAPH

The **PARAGRAPH** type stores long text content.

Common uses:

* descriptions
* blog content
* notes
* comments

Example:

```json theme={null}
{
  "bio": "Dara Singh is a sample user created for demonstration purposes."
}
```

***

## DECIMAL

The **DECIMAL** type stores numbers with decimal values.

Common uses:

* prices
* ratings
* percentages
* measurements

Example:

```json theme={null}
{
  "rating": 4.8
}
```

***

## DATE

The **DATE** type stores a calendar date.

Common uses:

* birth date
* event date
* joining date

Example:

```json theme={null}
{
  "birth_date": "1988-05-12"
}
```

***

## DATETIME

The **DATETIME** type stores both date and time.

Common uses:

* created\_at
* updated\_at
* event timestamps

Example:

```json theme={null}
{
  "created_at": "2026-03-10T10:30:00Z"
}
```

***

## PASSWORD

The **PASSWORD** type stores secure password values.

Passwords are encrypted before being stored.

Example:

```json theme={null}
{
  "password": "********"
}
```

***

## EMAIL

The **EMAIL** type stores valid email addresses.

Common uses:

* user login
* account registration
* contact information

Example:

```json theme={null}
{
  "email": "dara@example.com"
}
```

***

## PHONE

The **PHONE** type stores phone numbers.

Example:

```json theme={null}
{
  "phone": "+91 9898989898"
}
```

***

## BOOLEAN

The **BOOLEAN** type stores true or false values.

Common uses:

* active status
* verification status
* feature flags

Example:

```json theme={null}
{
  "is_active": true
}
```

***

## Example Table

Example **users** table:

| Field       | Type      |
| ----------- | --------- |
| id          | NUMBER    |
| name        | TEXT      |
| email       | EMAIL     |
| phone       | PHONE     |
| bio         | PARAGRAPH |
| is\_active  | BOOLEAN   |
| created\_at | DATETIME  |

### Example Record

```json theme={null}
{
  "id": 1,
  "name": "Dara Singh",
  "email": "dara@example.com",
  "phone": "+91 9898989898",
  "bio": "Sample user for API demonstration",
  "is_active": true
}
```

***

## Example API Request

After creating a table, EazeMyAPI automatically generates APIs.

### Example Endpoint

```
https://api.eazemyapi.com/demo-project/users/v1/list
```

### Example Request

```bash theme={null}
curl https://api.eazemyapi.com/demo-project/users/v1/list \
  -H "X-API-SIGNATURE: your-secret-key"
```

***

## Best Practices

When choosing field types:

* Use **TEXT** for short text
* Use **PARAGRAPH** for long content
* Use **NUMBER** for integers
* Use **DECIMAL** for prices or ratings
* Use **BOOLEAN** for true/false values
* Use **DATETIME** for timestamps

Correct field types make your APIs faster and easier to use.

***

## Next Step

Learn how database schema works in EazeMyAPI.

[Database Schema](/docs/database-schema)


# Frontend integration
Source: https://doc.eazemyapi.com/docs/frontend-integration



All API requests to EazeMyAPI must include the **API signature key** in the request header.

This key verifies that the request is authorized to access your project’s APIs.

***

## Required Header

Every API request must include the following header:

```
X-API-SIGNATURE: <secret-key>
```

***

### JavaScript (Axios)

```javascript theme={null}
import axios from "axios";

axios.get("https://api.eazemyapi.com/demo-project/users/v1/list", {
  headers: {
    "X-API-SIGNATURE": "your-secret-key"
  }
})
.then(res => console.log(res.data));
```

***

### PHP (cURL)

```php theme={null}
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, "https://api.eazemyapi.com/demo-project/users/v1/list");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "X-API-SIGNATURE: your-secret-key"
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
```

***

### Python (requests)

```python theme={null}
import requests

url = "https://api.eazemyapi.com/demo-project/users/v1/list"
headers = {
    "X-API-SIGNATURE": "your-secret-key"
}

response = requests.get(url, headers=headers)
print(response.json())
```

***

### cURL

```bash theme={null}
curl https://api.eazemyapi.com/demo-project/users/v1/list \
  -H "X-API-SIGNATURE: your-secret-key"
```

***

## API Key Scopes (Future Vision) (Future Vision)

In the future, EazeMyAPI will support **scoped API keys** to enhance security and control.

### Planned Capabilities

* **Read-only keys** (GET requests only)
* **Write keys** (POST, PUT, DELETE access)
* **Admin keys** (full access)
* **Table-level restrictions** (limit access to specific data)
* **Rate-limited keys** (control usage per key)

### Example (Future Format)

```json theme={null}
{
  "key": "abc123",
  "scopes": ["read:users", "write:posts"],
  "rate_limit": "1000/hour"
}
```

This will allow developers to safely use API keys in different environments (frontend, backend, third-party integrations).

***

## Security Best Practices

* Never expose the secret key in public repositories
* Do not store the key inside frontend code
* Use environment variables to store API keys
* Rotate keys if compromised

***

## Important Note

The API signature key provides full access to your project APIs.

Anyone with this key can perform API operations. Handle it securely.

If your application requires user-level security, implement authentication and access control separately.

***

## Framework Examples

### React

```javascript theme={null}
import React, { useEffect } from "react";

function App() {
  useEffect(() => {
    fetch("https://api.eazemyapi.com/demo-project/users/v1/list", {
      headers: {
        "X-API-SIGNATURE": "your-secret-key"
      }
    })
    .then(res => res.json())
    .then(data => console.log(data));
  }, []);

  return <div>Check console</div>;
}

export default App;
```

***

### Next.js

```javascript theme={null}
export async function getServerSideProps() {
  const res = await fetch("https://api.eazemyapi.com/demo-project/users/v1/list", {
    headers: {
      "X-API-SIGNATURE": "your-secret-key"
    }
  });

  const data = await res.json();

  return { props: { data } };
}
```

***

### Vue.js

```javascript theme={null}
export default {
  mounted() {
    fetch("https://api.eazemyapi.com/demo-project/users/v1/list", {
      headers: {
        "X-API-SIGNATURE": "your-secret-key"
      }
    })
    .then(res => res.json())
    .then(data => console.log(data));
  }
};
```

***

### Angular

```typescript theme={null}
import { HttpClient, HttpHeaders } from '@angular/common/http';

constructor(private http: HttpClient) {}

ngOnInit() {
  const headers = new HttpHeaders({
    'X-API-SIGNATURE': 'your-secret-key'
  });

  this.http.get('https://api.eazemyapi.com/demo-project/users/v1/list', { headers })
    .subscribe(res => console.log(res));
}
```

***

### Flutter (Dart)

```dart theme={null}
import 'package:http/http.dart' as http;

void fetchData() async {
  var response = await http.get(
    Uri.parse('https://api.eazemyapi.com/demo-project/users/v1/list'),
    headers: {
      'X-API-SIGNATURE': 'your-secret-key'
    },
  );

  print(response.body);
}
```

***

### Android (Kotlin)

```kotlin theme={null}
val client = OkHttpClient()

val request = Request.Builder()
    .url("https://api.eazemyapi.com/demo-project/users/v1/list")
    .addHeader("X-API-SIGNATURE", "your-secret-key")
    .build()

val response = client.newCall(request).execute()
println(response.body?.string())
```

***

### iOS (Swift)

```swift theme={null}
import Foundation

var request = URLRequest(url: URL(string: "https://api.eazemyapi.com/demo-project/users/v1/list")!)
request.addValue("your-secret-key", forHTTPHeaderField: "X-API-SIGNATURE")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        print(String(data: data, encoding: .utf8)!)
    }
}

task.resume()
```


# Generate api
Source: https://doc.eazemyapi.com/docs/generate-api



EazeMyAPI automatically generates REST APIs based on the tables you create in your project.

Once your database schema is defined, the platform instantly creates API endpoints that allow applications to interact with your data.

No backend server code is required.

***

## API URL Structure

All EazeMyAPI endpoints follow this structure:

```
https://api.eazemyapi.com/{project}/{table}/{version}/{action}
```

| Parameter   | Description                              |
| ----------- | ---------------------------------------- |
| `{project}` | Your project identifier                  |
| `{table}`   | Database table name                      |
| `{version}` | API version                              |
| `{action}`  | Operation (list, create, update, delete) |

***

## How API Generation Works

The API generation process follows these steps:

```
Create Project
      ↓
Create Tables
      ↓
Define Fields
      ↓
EazeMyAPI Generates APIs
```

Each table you create becomes an API resource.

***

## Instant API Example

Here’s what happens in real-time when you create a table:

```
You create: users table
        ↓
API generated: /demo-project/users/v1/list
        ↓
You call API → Get data
```

### Example Endpoint

```
https://api.eazemyapi.com/demo-project/users/v1/list
```

### Example Response

```json theme={null}
{
  "success": true,
  "message": "Data found.",
  "data": [
    {
      "id": 1,
      "name": "Dara Singh",
      "email": "dara@example.com"
    }
  ]
}
```

This is generated instantly—no backend code required.

***

## Example Table

Example **users** table:

| Field       | Type     |
| ----------- | -------- |
| id          | NUMBER   |
| name        | TEXT     |
| email       | EMAIL    |
| phone       | PHONE    |
| created\_at | DATETIME |

After creating this table, EazeMyAPI automatically generates API endpoints.

***

## Generated API Endpoints

Typical endpoints generated for a table include:

### List Records

```
GET /{project}/users/{version}/list
```

***

### Create Record

```
POST /{project}/users/{version}/create
```

***

### Update Record

```
POST /{project}/users/{version}/update/{id}
```

***

### Delete Record

```
DELETE /{project}/users/{version}/delete/{id}
```

***

## Example API Request

### Endpoint

```
https://api.eazemyapi.com/demo-project/users/v1/list
```

### Request

```bash theme={null}
curl https://api.eazemyapi.com/demo-project/users/v1/list \
  -H "X-API-SIGNATURE: your-secret-key"
```

### Example Response

```json theme={null}
{
  "success": true,
  "message": "Data found.",
  "data": [
    {
      "id": 1,
      "name": "Dara Singh",
      "email": "dara@example.com"
    }
  ]
}
```

***

## Automatic CRUD Operations

Each generated API supports standard **CRUD operations**.

| Operation | Description             |
| --------- | ----------------------- |
| Create    | Add new records         |
| Read      | Retrieve records        |
| Update    | Modify existing records |
| Delete    | Remove records          |

***

## Benefits of Automatic API Generation

Using EazeMyAPI to generate APIs provides several advantages:

* No backend server setup required
* Faster development
* Standardized API structure
* Secure authentication support
* Easy frontend integration

Developers can focus on building applications instead of managing backend infrastructure.

***

## Related Documentation

Learn how to create tables:

[Create Tables](/docs/create-tables)

Understand API endpoints:

[API Endpoints](/docs/api-endpoints)

Learn about authentication:

[Authentication](/docs/authentication)


# Getting started
Source: https://doc.eazemyapi.com/docs/getting-started



Describe your app → AI creates database → APIs ready instantly.

EazeMyAPI allows you to create a complete backend for your application without writing server code.

You can either:

* Generate your backend **using AI**
* Build your backend **manually by creating tables**

This guide shows the fastest way to start using **AI-powered backend generation**.

***

## Option 1 — Create Backend with AI (Recommended)

The easiest way to start is using the **AI Project Generator**.

Instead of manually creating tables, simply describe your application idea and EazeMyAPI will generate the backend automatically.

***

### Step 1 — Login to Dashboard

Visit:

```
https://eazemyapi.com
```

Login to your account.

***

### Step 2 — Open AI Project Generator

Click:

```
Create Project → Generate with AI
```

***

### Step 3 — Describe Your Application

Write a short description of the backend you want to build.

#### Example

```
Create a backend for a task management app where users can create projects and tasks.
```

***

### Step 4 — AI Generates Backend

EazeMyAPI will automatically generate:

* Database tables
* Table fields
* API endpoints

#### Example Generated Structure

* Users
* Projects
* Tasks

Each table will be connected and ready for use.

***

### Real AI Example

Here’s what happens when you describe your app:

```
Input:
"Task management app where users can create projects and tasks"

↓

AI Output:
- users table
- projects table
- tasks table
- relationships created automatically
- APIs generated instantly
```

This entire backend is created within seconds—no manual setup required.

***

### Step 5 — APIs Are Ready

Once the backend is generated, EazeMyAPI automatically creates REST APIs.

#### Example Endpoints

```
GET    /{project}/tasks/{version}/list
POST   /{project}/tasks/{version}/create
POST   /{project}/tasks/{version}/update/{id}
DELETE /{project}/tasks/{version}/delete/{id}
```

Your backend is now ready.

***

## Option 2 — Manual Backend Creation

You can also build your backend manually.

### Steps

1. Create a project
2. Create database tables
3. APIs are generated automatically

Continue reading:

[Creating Your First Project](create-project)

***

## Connect Your Frontend

Once your backend is ready, you can connect it with:

* React
* Next.js
* Flutter
* Android
* iOS

Continue to:

[Frontend Integration](frontend-integration)


# How eazemyapi works
Source: https://doc.eazemyapi.com/docs/how-eazemyapi-works



EazeMyAPI allows developers to build backend systems instantly **without writing backend server code**.

Instead of manually creating databases, writing APIs, configuring authentication, and deploying backend infrastructure, EazeMyAPI automates the entire backend workflow.

Developers can either:

* Create database tables manually
* Use **AI to generate backend structures automatically**

If you are new to EazeMyAPI, start with:

[Getting Started](/docs/getting-started)

***

## Traditional Backend Development

In a traditional setup, building a backend requires:

1. Designing the database schema
2. Writing backend server logic
3. Creating REST API endpoints
4. Implementing authentication
5. Deploying infrastructure

This process can take **days or weeks**.

EazeMyAPI reduces this to **minutes**.

***

## The EazeMyAPI Workflow

```
Create Project
     ↓
Define Tables OR Use AI
     ↓
EazeMyAPI Generates APIs
     ↓
Secure APIs
     ↓
Connect Frontend
```

***

## 1. Create a Project

A **project** represents your backend application.

Each project includes:

* Database tables
* Generated APIs
* Authentication configuration
* Custom queries

Start here:

[Create Project](/docs/create-project)

***

## 2. Define Database Tables

Define your data structure using tables.

Example:

| Field       | Type     |
| ----------- | -------- |
| id          | NUMBER   |
| name        | TEXT     |
| email       | EMAIL    |
| created\_at | DATETIME |

Tables are the foundation of your backend.

[Create Tables](/docs/create-tables)

***

## 3. APIs Are Generated Automatically

Once tables are created, APIs are generated instantly.

### Example Endpoints

```
GET    /{project}/users/{version}/list
POST   /{project}/users/{version}/create
POST   /{project}/users/{version}/update/{id}
DELETE /{project}/users/{version}/delete/{id}
```

No manual backend coding is required.

***

## 4. Secure APIs with Authentication

All APIs are protected using an API signature key.

### Example

```bash theme={null}
curl https://api.eazemyapi.com/demo-project/users/v1/list \
  -H "X-API-SIGNATURE: your-secret-key"
```

Only authorized requests can access your APIs.

[Authentication](/docs/authentication)

***

## 5. Connect Your Frontend

Connect your frontend directly to APIs.

```javascript theme={null}
fetch("https://api.eazemyapi.com/demo-project/users/v1/list", {
  headers: {
    "X-API-SIGNATURE": "your-secret-key"
  }
})
.then(res => res.json())
.then(data => console.log(data));
```

Supported platforms:

* React
* Next.js
* Flutter
* Android
* iOS

[Frontend Integration](/docs/frontend-integration)

***

## AI Backend Generation

You can generate backend using AI.

### Example Input

```
Task management app with users and tasks
```

### AI Output

* users table
* tasks table
* relationships created
* APIs generated instantly

This allows you to go from idea → backend in seconds.

***

## AI + Developer Control

Even with AI, you have full control.

You can:

* Modify tables
* Add fields
* Define relationships
* Write custom queries

[Custom Queries](/docs/custom-queries)

***

## Visual Workflow

```
Idea
 ↓
Create Project
 ↓
Define Tables OR Use AI
 ↓
APIs Generated
 ↓
Secure APIs
 ↓
Connect Frontend
```

***

## When to Use EazeMyAPI

Use EazeMyAPI when you want to:

* Build MVPs quickly
* Prototype ideas
* Generate APIs instantly
* Avoid backend complexity
* Focus on product features

***

## Final Example (End-to-End)

Here’s a complete example showing how EazeMyAPI works from idea to API response.

### Step 1 — Idea

```
User management system
```

***

### Step 2 — Table Created

| Field       | Type     |
| ----------- | -------- |
| id          | NUMBER   |
| name        | TEXT     |
| email       | EMAIL    |
| created\_at | DATETIME |

***

### Step 3 — API Generated

```
GET    /demo-project/users/v1/list
POST   /demo-project/users/v1/create
POST   /demo-project/users/v1/update/{id}
DELETE /demo-project/users/v1/delete/{id}
```

***

### Step 4 — API Request

```bash theme={null}
curl https://api.eazemyapi.com/demo-project/users/v1/list \
  -H "X-API-SIGNATURE: your-secret-key"
```

***

### Step 5 — API Response

```json theme={null}
{
  "success": true,
  "message": "Data found.",
  "data": [
    {
      "id": 1,
      "name": "Dara Singh",
      "email": "dara@example.com"
    }
  ]
}
```

***

This entire flow—from idea to working API—takes just a few minutes in EazeMyAPI.

***

## Copy & Try

You can test this API instantly.

### Endpoint

```
https://api.eazemyapi.com/demo-project/users/v1/list
```

### cURL (Copy & Run)

```bash theme={null}
curl https://api.eazemyapi.com/demo-project/users/v1/list \
  -H "X-API-SIGNATURE: your-secret-key"
```

Simply copy the above command and run it in your terminal to see the API response immediately.

***

## Next Step

Start building your backend:

[Getting Started](/docs/getting-started)


# Introduction
Source: https://doc.eazemyapi.com/docs/introduction



EazeMyAPI is a platform that allows developers to create backend APIs instantly **without writing backend server code**.

Instead of manually building backend infrastructure, developers can define database tables or describe their application using AI. EazeMyAPI automatically generates the backend APIs required to power the application.

This allows developers to move from **idea to working backend in minutes**.

***

## The Problem EazeMyAPI Solves

Building a backend for an application usually requires several steps:

* Designing the database schema
* Writing backend server code
* Creating REST API endpoints
* Implementing authentication
* Deploying backend infrastructure

For many developers and startups, this process can take **days or even weeks**.

EazeMyAPI simplifies this entire process by automatically generating backend APIs from your database structure.

***

## Key Features

### Instant API Generation

Define your database tables and EazeMyAPI automatically creates REST APIs for:

* Create records
* Fetch records
* Update records
* Delete records

#### Example Endpoints

```
GET    /{project}/users/{version}/list
POST   /{project}/users/{version}/create
POST   /{project}/users/{version}/update/{id}
DELETE /{project}/users/{version}/delete/{id}
```

No backend coding required.

***

### AI-Powered Backend Creation

EazeMyAPI includes AI-assisted backend generation.

Developers can describe their application idea and the platform generates:

* Database tables
* Field structures
* Table relationships
* API endpoints

#### Example Prompt

```
Create a backend for a blog platform with users, posts, and comments.
```

***

### Built-in Authentication

Every project includes authentication using an API signature key.

#### Example Request

```bash theme={null}
curl https://api.eazemyapi.com/demo-project/users/v1/list \
  -H "X-API-SIGNATURE: your-secret-key"
```

[Authentication](/docs/authentication)

***

### Frontend Ready APIs

Generated APIs can be used directly with modern frontend frameworks such as:

* React
* Next.js
* Flutter
* Vue
* Angular
* Android
* iOS

[Frontend Integration](/docs/frontend-integration)

***

## Example Workflow

A typical backend development workflow using EazeMyAPI:

```
Idea
↓
Create Project
↓
Define Tables OR Use AI
↓
APIs Generated
↓
Secure APIs
↓
Connect Frontend
```

Within minutes, developers can have a fully functional backend system.

***

## Who Should Use EazeMyAPI

EazeMyAPI is ideal for:

* Startup founders building MVPs
* Developers who want to create APIs quickly
* Teams prototyping new applications
* Mobile app developers needing backend infrastructure

Instead of spending weeks building backend systems, developers can focus on building product features.

***

## Final Example

### Idea

```
User management system
```

### API Endpoint

```
https://api.eazemyapi.com/demo-project/users/v1/list
```

### Try It

```bash theme={null}
curl https://api.eazemyapi.com/demo-project/users/v1/list \
  -H "X-API-SIGNATURE: your-secret-key"
```

### Response

```json theme={null}
{
  "success": true,
  "message": "Data found.",
  "data": [
    {
      "id": 1,
      "name": "Dara Singh",
      "email": "dara@example.com"
    }
  ]
}
```

***

## Next Step

Learn how EazeMyAPI works internally:

[How EazeMyAPI Works](/docs/how-eazemyapi-works)


# Response format
Source: https://doc.eazemyapi.com/docs/response-format



All APIs generated by EazeMyAPI return responses in **JSON format**.

Each response follows a consistent structure so developers can easily process the data.

## Standard Response Structure

```json theme={null}
{
  "success": true,
  "message": "Data found.",
  "data": []
}
```

***

## Response Fields

| Field   | Description                                    |
| ------- | ---------------------------------------------- |
| success | Indicates whether the request was successful   |
| message | A human-readable message explaining the result |
| data    | The actual data returned by the API            |

***

## Demo Project API Request

**Demo Project Endpoint:**

```
https://api.eazemyapi.com/demo-project/v2/posts-by-category
```

**cURL Example:**

```bash theme={null}
curl https://api.eazemyapi.com/demo-project/v2/posts-by-category
```

[https://api.eazemyapi.com/soche-india/v2/posts-by-category](https://api.eazemyapi.com/soche-india/v2/posts-by-category)

````

**cURL Example:**

```bash
curl https://api.eazemyapi.com/soche-india/v2/posts-by-category
````

***

## Example Successful Response

```json theme={null}
{
  "success": true,
  "message": "Data found.",
  "data": [
    {
      "category_id": "c40a4731-a541-4d2b-af77-326af7142aab",
      "category_name": "Foods",
      "post_id": "2529c967-33a3-4f7b-aabd-84e90f861e14",
      "description": "Best restaurant in the world"
    },
    {
      "category_id": "c40a4731-a541-4d2b-af77-326af7142aab",
      "category_name": "Foods",
      "post_id": "5f8b35c8-372c-4ab2-9c01-569085f05a72",
      "description": "Best restaurant in Ahmedabad"
    },
    {
      "category_id": "c40a4731-a541-4d2b-af77-326af7142aab",
      "category_name": "Foods",
      "post_id": "9de87c8f-3ac0-43d7-97ab-a68681b15f9e",
      "description": "Chaiwala in Ahmedabad"
    }
  ]
}
```

***

## Example Error Response

If an error occurs, the API returns:

```json theme={null}
{
  "success": false,
  "message": "Data not found",
  "data": []
}
```

***

## Response Types

Depending on the request, EazeMyAPI APIs may return different structures in the `data` field.

### Single Record

```json theme={null}
{
  "success": true,
  "message": "Data found.",
  "data": {
    "id": 1,
    "name": "Dara Singh",
    "email": "dara.singh@example.com"
  }
}
```

### Multiple Records

```json theme={null}
{
  "success": true,
  "message": "Data found.",
  "data": [
    { "name": "Dara Singh" },
    { "name": "Amit" }
  ]
}
```

***

## Best Practices

When working with EazeMyAPI responses:

* Always check the **success** field first
* Use the **message** field to display user-friendly messages
* Process **data** only when `success = true`

***

## Related Documentation

* [Database Schema](/docs/database-schema)
* [Field Types](/docs/field-types)


# Backend architecture for startup mvp
Source: https://doc.eazemyapi.com/guides/backend-architecture-for-startup-mvp



Modern backend platforms now include AI-assisted development to simplify backend architecture.

With EazeMyAPI, you do not need to manually design database schemas or write backend APIs.

Workflow:

Describe your app → AI creates database → APIs ready instantly.

***

## How AI Backend Generation Works

### Step 1 — Describe Your Application

Instead of designing the backend manually, you describe your application idea.

Example prompt:

```
Create a backend for a social media app with users, posts, comments and likes.
```

***

### Step 2 — AI Generates Database Tables

EazeMyAPI automatically creates:

* Database tables
* Table fields
* Relationships between tables

Example generated tables:

Users
Posts
Comments
Likes

You can modify or extend these tables anytime.

Guide:

[Creating Tables](../docs/create-tables)

***

### Step 3 — APIs Are Generated Automatically

Once tables are created, REST APIs are generated instantly.

Example endpoints:

```
GET /posts
POST /posts
PUT /posts/{id}
DELETE /posts/{id}
```

Guide:

[Generating APIs](../docs/generate-api)

***

### Step 4 — Connect Your Frontend

Your frontend application can now connect to the generated APIs.

Supported frameworks include:

* React
* Next.js
* Flutter
* Android
* iOS

Guide:

[Frontend Integration](../docs/frontend-integration)


# Build backend with ai
Source: https://doc.eazemyapi.com/guides/build-backend-with-ai



Describe your app → AI creates database → APIs ready instantly.

Modern applications require a backend with database tables, APIs, and authentication.
Traditionally this requires backend development, server setup, and deployment.

With **EazeMyAPI AI**, you can generate a complete backend in seconds.

Just describe your application and the AI will create:

* Database tables
* Table fields
* API endpoints

No backend coding required.

If you are new to the platform:

[Getting Started](../docs/getting-started)

***

# Step 1 — Open AI Project Generator

Login to the EazeMyAPI dashboard.

Create a new project using the **AI generator**.

Guide:

[Creating Your First Project](../docs/create-project)

***

# Step 2 — Describe Your Application

Write a short description of your backend.

Example prompt:

```
Create a backend for a task management app with users, projects and tasks.
```

Another example:

```
Build a backend for an e-commerce app with users, products and orders.
```

***

# Step 3 — AI Generates Backend

EazeMyAPI AI automatically creates:

* Database tables
* Fields for each table
* Relationships between tables
* REST APIs for each table

Example generated structure:

Users
Projects
Tasks

You can modify or extend the schema anytime.

If you want to understand tables better:

[Creating Tables](../docs/create-tables)

***

# Step 4 — APIs Are Ready Instantly

Once the backend is generated, APIs are immediately available.

Example endpoints:

```
GET /tasks
POST /tasks
PUT /tasks/{id}
DELETE /tasks/{id}
```

Learn how APIs are generated:

[Generating APIs](../docs/generate-api)

***

# Step 5 — Secure Your APIs

All requests require the API signature key.

Example header:

```
X-API-SIGNATURE: your-secret-key
```

Authentication guide:

[Authentication](../docs/authentication)

***

# Step 6 — Connect Your Frontend

You can connect the generated APIs with any frontend framework.

Supported platforms:

* React
* Next.js
* Flutter
* Android
* iOS

Integration guide:

[Frontend Integration](../docs/frontend-integration)

***

# Example API Request

```javascript theme={null}
fetch("https://api.eazemyapi.com/tasks", {
  headers: {
    "X-API-SIGNATURE": "your-secret-key"
  }
})
```

Your backend is now fully functional.

***

# Why Developers Use AI Backend Generation

Traditional backend development requires:

* Designing database schema
* Writing backend code
* Creating API routes
* Deploying servers

With EazeMyAPI AI, the process becomes:

```
Describe idea → AI generates backend → APIs ready
```

This makes it ideal for:

* Startup MVPs
* Mobile apps
* SaaS platforms
* Rapid prototypes

***

# Next Steps

Once your backend is ready, you can extend it with:

* Custom database queries
* Advanced API logic
* Frontend integrations

Continue learning:

* [Writing Custom Queries](../docs/custom-queries)
* [Generate REST APIs Without Coding](generate-rest-api)


# Build backend without coding
Source: https://doc.eazemyapi.com/guides/build-backend-without-coding



EazeMyAPI includes an **AI backend generator** that allows you to create a complete backend by simply describing your application.

Instead of manually designing tables and APIs, the AI automatically creates the backend structure for you.

Describe your app → AI creates database → APIs ready instantly.

***

## Step 1 — Open the AI Generator

Login to your EazeMyAPI dashboard.

Create a new project using the **AI generator**.

Guide:

[Creating Your First Project](../docs/create-project)

***

## Step 2 — Describe Your Application

Enter a short description of the backend you want to create.

Example prompt:

```
Create a backend for a food delivery app with users, restaurants, menu items and orders.
```

Another example:

```
Build a backend for a social media app with users, posts, comments and likes.
```

***

## Step 3 — AI Generates the Database Structure

EazeMyAPI AI automatically creates:

* Database tables
* Table fields
* Relationships between tables

Example generated tables:

Users
Restaurants
MenuItems
Orders

You can modify or extend these tables anytime.

Guide:

[Creating Tables](../docs/create-tables)

***

## Step 4 — APIs Are Generated Automatically

Once the tables are created, REST APIs are instantly generated.

Example endpoints:

```
GET /orders
POST /orders
PUT /orders/{id}
DELETE /orders/{id}
```

Guide:

[Generating APIs](../docs/generate-api)

***

## Step 5 — Secure Your APIs

All API requests require the API signature key.

Example header:

```
X-API-SIGNATURE: your-secret-key
```

Guide:

[Authentication](../docs/authentication)

***

## Step 6 — Connect Your Frontend

Now you can connect your APIs to any frontend application.

Supported platforms include:

* React
* Next.js
* Flutter
* Android
* iOS

Guide:

[Frontend Integration](../docs/frontend-integration)

***

Your backend is now fully functional and ready for development.


# Build mvp backend
Source: https://doc.eazemyapi.com/guides/build-mvp-backend



Startups often need a backend quickly to validate ideas.
EazeMyAPI allows you to generate a production-ready backend without writing server code.

This guide shows how to build an MVP backend in a few simple steps.

***

## Step 1 — Create a Project

Login to the dashboard.

Create a new project for your application.

Example:

```
Project Name: StartupMVP
```

If you are new to EazeMyAPI, read the full guide:

[Creating Your First Project](../docs/create-project)

Each project contains its own database and APIs.

***

## Step 2 — Create Database Tables

Define your core data structure.

Example tables for a startup:

Users
Products
Orders

Example **Users table fields**:

```
id
name
email
password
created_at
```

Learn how to create tables in detail:

[Creating Tables](../docs/create-tables)

Once the table is created, EazeMyAPI prepares backend APIs automatically.

***

## Step 3 — Generate APIs

EazeMyAPI automatically generates REST APIs such as:

```
GET /users
POST /users
PUT /users/{id}
DELETE /users/{id}
```

These APIs allow your frontend to interact with your database instantly.

Read the full API guide:

[Generating APIs](../docs/generate-api)

***

## Step 4 — Secure Your APIs

Include your API signature key in requests.

Example header:

```
X-API-SIGNATURE: your-secret-key
```

This ensures only authorized requests access your backend.

See the authentication guide:

[Authentication](../docs/authentication)

***

## Step 5 — Connect Your Frontend

Your APIs can be used with:

React
Next.js
Flutter
Android
iOS

Example JavaScript request:

```javascript theme={null}
fetch("https://api.eazemyapi.com/users", {
  headers: {
    "X-API-SIGNATURE": "your-secret-key"
  }
})
```

Read the integration guide:

[Frontend Integration](../docs/frontend-integration)

***

## Why Startups Use EazeMyAPI

Traditional backend development requires:

Server setup
Database configuration
API development
Deployment infrastructure

EazeMyAPI simplifies this process and allows founders to launch MVPs faster.

***

## Next Steps

You can extend your backend by adding:

Authentication
Custom queries
Advanced database relationships

Learn more:

* [Authentication](../docs/authentication)
* [Writing Custom Queries](../docs/custom-queries)
* [Getting Started](../docs/getting-started)


# Build saas mvp in 48 hours
Source: https://doc.eazemyapi.com/guides/build-saas-mvp-in-48-hours



Launching a SaaS product does not require months of development.

Many successful startups begin with a **Minimum Viable Product (MVP)** that focuses only on the core problem.

This guide explains how you can build a functional SaaS MVP in **48 hours** using modern tools and rapid backend development platforms like EazeMyAPI.

***

# What is a SaaS MVP?

A SaaS MVP is the **simplest version of your product that solves a real problem for users**.

Instead of building every feature, the goal is to launch quickly and validate your idea.

Typical MVP components include:

* User authentication
* Core feature
* Database storage
* Basic frontend interface

***

# Example SaaS Idea

Suppose you want to build a **task management SaaS**.

Core features might include:

* User accounts
* Create tasks
* Edit tasks
* Delete tasks

Everything else can be added later.

***

# Day 1 — Planning and Backend Setup

Describe your app → AI creates database → APIs ready instantly.

## Step 1 — Define the Core Problem

Before writing any code, clearly define the problem your product solves.

Example:

> Help teams organize tasks in one place.

Focus on solving **one primary problem**.

***

## Step 2 — Design Your Data Model

Think about what data your application needs.

Example tables:

Users
Projects
Tasks

Example **Tasks table fields**:

```
id
title
description
status
created_at
```

Guide:

[Creating Tables](../docs/create-tables)

***

## Step 3 — Generate Backend APIs

Instead of manually writing backend code, you can generate APIs automatically.

With EazeMyAPI:

* Create database tables
* APIs are generated instantly

Example endpoints:

```
GET /tasks
POST /tasks
PUT /tasks/{id}
DELETE /tasks/{id}
```

Guide:

[Generating APIs](../docs/generate-api)

***

## Step 4 — Secure Your Backend

Your APIs must be protected.

EazeMyAPI secures requests using an API signature key.

Example header:

```
X-API-SIGNATURE: your-secret-key
```

Guide:

[Authentication](../docs/authentication)

***

# Day 2 — Build the Frontend

Once your backend is ready, connect it to a frontend application.

Common frontend frameworks include:

* React
* Next.js
* Flutter
* Vue

Guide:

[Frontend Integration](../docs/frontend-integration)

***

## Example API Request

```javascript theme={null}
fetch("https://api.eazemyapi.com/tasks", {
  headers: {
    "X-API-SIGNATURE": "your-secret-key"
  }
})
```

This retrieves tasks from your backend.

***

# Faster MVP Development with AI

EazeMyAPI also includes an **AI backend generator**.

Instead of designing tables manually, you can describe your application idea.

Example prompt:

```
Create a backend for a task management SaaS with users, projects and tasks.
```

The AI automatically generates:

* Database tables
* Table fields
* REST APIs

Guide:

[Build Backend with AI in 30 Seconds](build-backend-with-ai)

***

# MVP Development Checklist

Before launching your MVP, ensure you have:

* User authentication
* Core feature working
* Database storage
* Basic UI
* Error handling

Avoid building unnecessary features.

***

# Launch and Collect Feedback

Once your MVP works, release it to early users.

You can launch on platforms like:

* Product Hunt
* Indie Hackers
* Hacker News

User feedback helps improve the product.

***

# Common MVP Mistakes

Many startups fail because they overbuild their first version.

Common mistakes include:

* Adding too many features
* Spending months on infrastructure
* Ignoring user feedback

The goal of an MVP is **learning, not perfection**.

***

# Final Thoughts

Building a SaaS product is easier than ever with modern development tools.

By using platforms like EazeMyAPI, founders can move from **idea → working backend quickly**, allowing them to focus on product validation and growth.

Start building your backend today:

[Getting Started](../docs/getting-started)


# Firebase alternative
Source: https://doc.eazemyapi.com/guides/firebase-alternative



Firebase is a popular backend platform, but many startups look for alternatives that offer more control and simpler API management.

**EazeMyAPI** provides a lightweight approach to building backend APIs without complex infrastructure.

If you are new to the platform, start here:

[Getting Started with EazeMyAPI](../docs/getting-started)

***

## What Firebase Offers

Firebase provides:

* Authentication
* Database services
* Cloud functions
* Hosting

However, it often introduces complexity for simple backend needs.

***

## Why Some Developers Look for Alternatives

Common reasons include:

* Vendor lock-in
* Complex configuration
* Limited query flexibility
* Pricing concerns at scale

***

## How EazeMyAPI Helps

EazeMyAPI focuses on one core goal:

**Generating APIs instantly from your database.**

Features include:

* No-code backend builder
* Instant REST API generation
* Custom query support
* Simple project structure

Learn how API generation works:

[Generating APIs](../docs/generate-api)

***

## Typical Use Cases

EazeMyAPI works well for:

* Startup MVPs
* Mobile app backends
* Small SaaS products
* Rapid product prototypes

If you are building an MVP backend, see:

[Build MVP Backend Guide](build-mvp-backend)

***

## Example Workflow

1. Create project
   → [Creating Your First Project](../docs/create-project)

2. Create tables
   → [Creating Tables](../docs/create-tables.md)

3. APIs generated automatically
   → [Generating APIs](../docs/generate-api.md)

4. Connect frontend application
   → [Frontend Integration](../docs/frontend-integration.md)

Your backend becomes ready in minutes.

***

## Security

All API requests are secured using an API signature key.

Example header:

```
X-API-SIGNATURE: your-secret-key
```

Learn how authentication works:

[Authentication Guide](../docs/authentication.md)

***

## Advanced Backend Logic

For complex queries or advanced data operations, EazeMyAPI allows custom queries.

Learn more:

[Writing Custom Queries](../docs/custom-queries.md)

***

## Final Thoughts

Firebase remains a powerful platform, but many startups prefer simpler backend tools that allow faster MVP development.

EazeMyAPI focuses on helping developers move from **idea → working backend quickly**.

To start building your backend today:

[Getting Started](../docs/getting-started.md)


# Generate rest api
Source: https://doc.eazemyapi.com/guides/generate-rest-api



Building REST APIs traditionally requires backend development, server configuration, and deployment setup.

EazeMyAPI allows developers to generate REST APIs instantly from database tables — and now even faster using **AI-powered backend generation**.

If you are new to EazeMyAPI, start here:

[Getting Started](../docs/getting-started)

***

# Traditional API Development

Typical backend workflow:

* Create database
* Write backend code
* Build API routes
* Handle validation
* Deploy server

This process can take **days or weeks**.

***

# Generate APIs with AI (Fastest Way)

EazeMyAPI includes an **AI backend generator** that can create database tables and APIs automatically.

Instead of manually designing tables, simply describe your application.

Example prompt:

```
Create a backend for an e-commerce app with users, products, orders and payments.
```

The AI will generate:

* Users table
* Products table
* Orders table
* Payments table

Each table will include appropriate fields and relationships.

APIs are automatically generated for every table.

To learn more:

[Getting Started with AI](../docs/getting-started)

***

# Manual API Generation

You can also generate APIs manually by creating tables.

### Step 1 — Create a Project

Create a backend workspace for your application.

Guide:

[Creating Your First Project](../docs/create-project)

***

### Step 2 — Create Tables

Define the data structure for your application.

Example table:

```
products
```

Fields:

```
id
name
price
created_at
```

Detailed guide:

[Creating Tables](../docs/create-tables)

***

### Step 3 — APIs Generated Automatically

Once tables are created, EazeMyAPI generates REST APIs instantly.

Example endpoints:

```
GET /products
POST /products
GET /products/{id}
PUT /products/{id}
DELETE /products/{id}
```

Learn more:

[Generating APIs](../docs/generate-api)

***

# API Authentication

Every request must include your API signature key.

Example header:

```
X-API-SIGNATURE: your-secret-key
```

Authentication guide:

[Authentication](../docs/authentication)

***

# API Example

```javascript theme={null}
fetch("https://api.eazemyapi.com/products", {
  headers: {
    "X-API-SIGNATURE": "your-secret-key"
  }
})
```

The API returns JSON data that your application can use.

***

# Advantages

* Instant backend setup
* AI-powered backend generation
* No server maintenance
* Rapid MVP development
* Simple API structure

If you want to launch a startup backend quickly, see:

[Build MVP Backend Guide](build-mvp-backend.md)

***

# Next Steps

You can now connect your backend APIs to frontend frameworks like:

* React
* Next.js
* Flutter
* Vue

Frontend integration guide:

[Frontend Integration](../docs/frontend-integration.md)

***

# Advanced Backend Logic

For advanced database operations, filtering, or analytics queries, use custom queries.

Learn more:

[Writing Custom Queries](../docs/custom-queries.md)


# Supabase vs firebase vs eazemyapi
Source: https://doc.eazemyapi.com/guides/supabase-vs-firebase-vs-eazemyapi



Choosing the right backend platform is an important decision for startups and developers.

Three popular approaches today are:

* Firebase
* Supabase
* EazeMyAPI

Each tool solves backend development differently.

This guide compares their features and helps you choose the right solution.

If you are new to EazeMyAPI:

[Getting Started](../docs/getting-started)

***

# Quick Overview

| Platform  | Type                             | Best For                              |
| --------- | -------------------------------- | ------------------------------------- |
| Firebase  | Backend-as-a-Service             | Mobile apps, real-time apps           |
| Supabase  | Open-source Firebase alternative | Developers who prefer SQL             |
| EazeMyAPI | AI-powered backend builder       | Startup MVPs and rapid API generation |

***

# Firebase

Firebase is a Backend-as-a-Service platform created by Google.

It provides a collection of backend tools including authentication, hosting, and real-time databases.

### Key Features

* Authentication
* Firestore database
* Cloud functions
* Hosting
* Analytics

### Advantages

* Strong Google ecosystem
* Good for real-time apps
* Popular among mobile developers

### Challenges

* Vendor lock-in
* Complex pricing at scale
* Limited query flexibility
* Requires configuration for many features

***

# Supabase

Supabase is an open-source backend platform built on PostgreSQL.

It aims to be a developer-friendly alternative to Firebase.

### Key Features

* PostgreSQL database
* Authentication
* Storage
* Realtime APIs
* Edge functions

### Advantages

* SQL-based database
* Open source
* Strong developer ecosystem

### Challenges

* Requires database knowledge
* Backend configuration required
* Less beginner-friendly for founders

***

# EazeMyAPI

EazeMyAPI focuses on **rapid backend generation for startups and developers**.

Instead of configuring infrastructure, you simply create tables or use AI to generate your backend.

### Key Features

* No-code backend builder
* Automatic REST API generation
* Custom query support
* Simple project structure
* AI backend generator

Learn how to generate backend with AI:

[Build Backend with AI in 30 Seconds](build-backend-with-ai)

***

# Backend Creation Workflow

### Firebase

Typical flow:

Create project
Configure database
Write cloud functions
Deploy services

***

### Supabase

Typical flow:

Create project
Design PostgreSQL schema
Configure APIs
Deploy backend

***

### EazeMyAPI

Typical flow:

Create project
Generate backend with AI
APIs ready instantly

Guide:

[Generating APIs](../docs/generate-api)

***

# Feature Comparison

| Feature               | Firebase                | Supabase          | EazeMyAPI      |
| --------------------- | ----------------------- | ----------------- | -------------- |
| Backend setup         | Medium complexity       | Developer-focused | Very simple    |
| Database              | Firestore / Realtime DB | PostgreSQL        | Table-based    |
| API generation        | Requires functions      | Auto-generated    | Auto-generated |
| AI backend generation | No                      | No                | Yes            |
| Best for              | Mobile apps             | SQL developers    | Startup MVPs   |

***

# When to Use Firebase

Firebase is a good choice if you need:

* Real-time mobile applications
* Deep Google ecosystem integration
* Built-in analytics and messaging

***

# When to Use Supabase

Supabase is ideal if:

* You prefer SQL databases
* You want an open-source backend
* You are comfortable managing database structure

***

# When to Use EazeMyAPI

EazeMyAPI works best when you want:

* Fast MVP backend creation
* Automatic API generation
* AI-assisted backend design
* Minimal backend infrastructure management

Learn how to create your first project:

[Creating Your First Project](../docs/create-project)

***

# Example Use Case

Startup founders often need to validate ideas quickly.

Typical process using EazeMyAPI:

1. Create project
2. Generate backend using AI
3. APIs generated automatically
4. Connect frontend

Guides:

* [Creating Tables](../docs/create-tables)
* [Frontend Integration](../docs/frontend-integration)

***

# Final Thoughts

Firebase and Supabase are powerful backend platforms.

However, many startups prefer faster backend development workflows.

EazeMyAPI focuses on helping developers move from **idea → working backend quickly** using automation and AI.

To start building your backend:

[Getting Started](../docs/getting-started)


# Top backend tools for startups 2026
Source: https://doc.eazemyapi.com/guides/top-backend-tools-for-startups-2026



Choosing the right backend platform is one of the most important technical decisions for startups.

A good backend tool should help you:

* Build APIs quickly
* Manage databases easily
* Scale as your product grows
* Launch MVPs fast

In this guide, we explore **10 popular backend tools used by startups in 2026**.

***

# 1. Firebase

Firebase is a Backend-as-a-Service platform created by Google.

It provides a collection of tools including authentication, hosting, real-time databases, and analytics.

### Key Features

* Firestore database
* Authentication
* Cloud functions
* Hosting
* Analytics

### Best For

Mobile apps and real-time applications.

***

# 2. Supabase

Supabase is an open-source backend platform built on PostgreSQL.

It provides authentication, database services, and APIs automatically generated from your database.

### Key Features

* PostgreSQL database
* Auto-generated APIs
* Authentication
* Realtime database updates

### Best For

Developers who prefer SQL and open-source tools.

***

# 3. EazeMyAPI

EazeMyAPI is a **no-code backend builder designed for startups and rapid MVP development**.

It allows developers to create backend APIs instantly by defining database tables or using AI.

### Key Features

* AI backend generator
* Automatic REST API generation
* Simple database table builder
* Custom query support

Developers can generate a backend in seconds using AI.

Guide:

[Build Backend with AI in 30 Seconds](build-backend-with-ai)

### Best For

Startup founders and teams who want to launch MVPs quickly.

***

# 4. Hasura

Hasura is a GraphQL engine that provides instant GraphQL APIs on top of databases.

### Key Features

* GraphQL APIs
* Database integration
* Role-based permissions
* Real-time subscriptions

### Best For

Teams building GraphQL-based applications.

***

# 5. Backendless

Backendless is a visual backend development platform.

It provides tools for building backend logic without writing code.

### Key Features

* Visual backend logic builder
* Database management
* Push notifications
* API services

### Best For

Low-code application development.

***

# 6. Appwrite

Appwrite is an open-source backend platform focused on developer productivity.

### Key Features

* Authentication
* Database
* Storage
* Serverless functions

### Best For

Developers who want an open-source backend.

***

# 7. Xano

Xano is a no-code backend builder that focuses on API creation and database management.

### Key Features

* API builder
* Database management
* Backend automation
* Scalable infrastructure

### Best For

No-code and low-code backend development.

***

# 8. PocketBase

PocketBase is a lightweight backend solution built around SQLite.

### Key Features

* Embedded database
* Authentication
* File storage
* Real-time subscriptions

### Best For

Small projects and lightweight apps.

***

# 9. Parse Platform

Parse is an open-source backend framework originally developed by Facebook.

### Key Features

* Database management
* Authentication
* Push notifications
* Cloud functions

### Best For

Apps requiring a customizable backend.

***

# 10. AWS Amplify

AWS Amplify is a development platform for building scalable applications using AWS services.

### Key Features

* Authentication
* GraphQL APIs
* Storage
* Hosting

### Best For

Applications that require deep AWS integration.

***

# How to Choose the Right Backend Tool

When selecting a backend platform, consider:

* Development speed
* Infrastructure complexity
* Cost at scale
* API flexibility
* Learning curve

For startups building MVPs quickly, tools that provide **automatic API generation and simple database management** are often preferred.

***

# Build Your Backend Quickly

If your goal is to move from idea to working backend quickly, tools like EazeMyAPI simplify the process.

Typical workflow:

1. Create project
2. Generate backend using AI
3. APIs ready instantly
4. Connect frontend

Guides:

* [Getting Started](../docs/getting-started)
* [Creating Tables](../docs/create-tables)
* [Frontend Integration](../docs/frontend-integration)

***

# Final Thoughts

Backend tools continue to evolve, making it easier than ever for startups to launch products quickly.

The best platform depends on your team’s experience, application requirements, and development speed.

Many modern startups prefer backend tools that **reduce infrastructure complexity and accelerate product development**.