███╗ ███╗ █████╗ ███████╗████████╗███████╗██████╗

████╗ ████║██╔══██╗██╔════╝╚══██╔══╝██╔════╝██╔══██╗

██╔████╔██║███████║███████╗ ██║ █████╗ ██████╔╝

██║╚██╔╝██║██╔══██║╚════██║ ██║ ██╔══╝ ██╔══██╗

██║ ╚═╝ ██║██║ ██║███████║ ██║ ███████╗██║ ██║

╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ ╚═╝ ╚══════╝╚═╝ ╚═╝

██╗ ██╗ ██████╗ ██╗ ██╗██████╗ █████╗ ██████╗ ██╗███████╗

╚██╗ ██╔╝██╔═══██╗██║ ██║██╔══██╗ ██╔══██╗██╔══██╗██║██╔════╝

╚████╔╝ ██║ ██║██║ ██║██████╔╝ ███████║██████╔╝██║███████╗

╚██╔╝ ██║ ██║██║ ██║██╔══██╗ ██╔══██║██╔═══╝ ██║╚════██║

██║ ╚██████╔╝╚██████╔╝██║ ██║ ██║ ██║██║ ██║███████║

╚═╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝

Everything you need to transform your data into production-ready REST APIs with step-by-step guides and examples

Getting Started

Quick start guide to upload and generate your first API

API Features

Complete REST API endpoints with filtering, sorting, and pagination

Code Examples

Ready-to-use code snippets in JavaScript, Python, and cURL

Getting Started

1. Upload Your Data

Upload CSV, Excel, JSON, Parquet, or text files to the platform. The system automatically detects and validates your file format.

Supported formats: .csv, .xlsx, .xls, .json, .parquet, .txt

File size limit: 50MB. Data validation occurs during upload to ensure data integrity.

2. Preview Your Data

Review your data structure, column types, and sample records before generating the API. Check for data quality issues and column type detection.

Automatic column type detection (string, number, date, boolean)
Data quality indicators and validation warnings
Sample record preview (first 100 rows)
Memory usage estimation for API performance

3. Generate API

Click "Generate API" to create your REST endpoints with full CRUD operations, filtering, sorting, and pagination. The process typically takes 30-60 seconds.

Automatic REST endpoint creation (GET, POST, PUT, DELETE)
Advanced query parameters for filtering and sorting
Pagination support with configurable page sizes
CORS-enabled for cross-origin requests

4. Use Your API

Test your API endpoints, view interactive documentation, and download deployment files for production use.

Interactive API documentation with live testing
Code examples in JavaScript, Python, and cURL
Download deployment packages (Docker, Cloud Run)
Analytics dashboard for API usage monitoring

5. Advanced Features (Optional)

Explore additional tools for data management and interaction:

Data Editor: Excel-like interface for real-time data editing
MCP Chat: Natural language queries to interact with your APIs using AI
API Analytics: Monitor performance, usage, and error rates
Deployment: One-click deployment to Google Cloud Run

API Features

Endpoints

GET /data - Retrieve all records
GET /data/{id} - Get specific record
POST /data - Create new record
PUT /data/{id} - Update record
DELETE /data/{id} - Delete record

Query Parameters

limit - Number of records (default: 10)
offset - Skip records (default: 0)
sort_by - Sort column
sort_order - asc/desc
Column filters - filter by any column value

Data Editor

The Data Editor provides an Excel-like spreadsheet interface for viewing, editing, and managing your API data in real-time.

Key Features

Real-time Editing

Edit cells directly in the spreadsheet interface with automatic type detection and validation.

Formula Bar

View and edit cell values in a dedicated formula bar with cell reference display (A1, B2, etc.).

CRUD Operations

Create, read, update, and delete records with one-click actions and bulk operations.

Data Validation

Automatic data type validation with visual indicators for errors and warnings.

Toolbar Functions

Refresh: Reload data from the API to see latest changes
Save Changes: Commit all modifications to the database
Add Row: Insert new records with default values
Export CSV: Download current data as CSV file
Pagination: Navigate through large datasets (50, 100, 250, or 500 rows per page)

How to Use

Navigate to the Data Editor from your API dashboard
Select an API from the dropdown or enter an API ID manually
Click cells to edit values directly or use the formula bar
Right-click cells for context menu options (copy, paste, clear)
Use toolbar buttons to add rows, refresh data, or export to CSV
Click "Save Changes" to persist all modifications

Data Types Supported

Text

String values with multi-line support

Numbers

Integer and decimal values with right alignment

Booleans

True/false values with checkbox display

MCP Chat

The MCP Chat feature provides a natural language interface for interacting with your APIs using the Model Context Protocol (MCP). Ask questions about your data in plain English and get intelligent responses powered by AI.

Natural Language Queries

Ask questions about your data in plain English and get intelligent AI-powered responses:

"What are the columns in this dataset?"

"Show me a summary of the data"

"Find records where sales > 1000"

"Compare data between these two APIs"

"What's the trend in user registrations?"

Key Features

AI-Powered Queries

Intelligent responses using natural language processing and AI.

Multi-API Support

Chat with multiple APIs simultaneously for comprehensive insights.

Context Awareness

Maintains conversation context across multiple queries.

Structured Responses

JSON-formatted responses perfect for programmatic use.

Advanced Capabilities

AI-Powered Responses: Intelligent answers using natural language processing
Multi-API Conversations: Query multiple APIs simultaneously for comprehensive insights
Context Awareness: Maintains conversation context across multiple queries
API Usage Tracking: Shows which APIs were used for each response

How to Use

Navigate to the MCP Chat page from the sidebar
Select one or multiple APIs from the selector at the top
Start chatting by typing questions in natural language
Use the interface to ask follow-up questions and explore your data
View structured responses with API usage information
Leverage AI-powered insights across multiple data sources

MCP Server

The Model Context Protocol (MCP) server enables AI models and tools to access your flat files through a standardized protocol.

What is MCP?

The Model Context Protocol (MCP) is a standardized way for AI models and tools to access external data sources and APIs. It provides a consistent interface for connecting various data providers to AI applications.

Key Benefits

Standardized Interface

Consistent way to access different data sources

Secure Access

Controlled access to your data with proper authentication

Multiple Formats

Support for CSV, JSON, Parquet, and other file formats

Real-time Updates

Live access to your changing data

How to Connect

For MCP Clients

Configure your MCP-compatible AI client to connect to the apiUI MCP server:

{
  "mcpServers": {
    "apiui": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/your/files"],
      "env": {
        "APIUI_BASE_URL": "https://apiui-backend-24bi767viq-uc.a.run.app"
      }
    }
  }
}
                                

Direct API Access

You can also access the MCP server directly via HTTP APIs:

GET /mcp/resources List Files

Retrieve a list of all available files with metadata

POST /mcp MCP Protocol

Send MCP protocol requests (resources/list, resources/read)

GET /mcp/resources/{filename} Read File

Direct access to read specific file content

File Browser

Browse and access all files available through your MCP server. Files uploaded to apiUI are automatically made available via MCP.

Supported File Formats

CSV Files

Comma-separated values with headers

JSON Files

Array of objects format

Parquet Files

Columnar storage format

API Documentation

Interactive API documentation with live testing, code examples, and comprehensive endpoint information.

Interactive Testing

Live API Testing: Test endpoints directly from the documentation
Parameter Input: Interactive forms for query parameters and request bodies
Response Viewer: Formatted JSON responses with syntax highlighting
Authentication: Built-in support for API key authentication

Code Examples

Ready-to-use code snippets in multiple programming languages:

JavaScript

Fetch API and Axios examples

Python

Requests library examples

cURL

Command-line examples

Endpoint Information

Dataset Overview

Complete information about your data structure, record count, and column details.

Data Preview

Sample records and data validation information.

API Endpoints

Detailed documentation for all REST endpoints with parameters and examples.

Analytics

Usage statistics, performance metrics, and error tracking.

How to Use

Select an API from your dashboard to view its documentation
Browse endpoint details and parameter requirements
Use the interactive testing forms to try API calls
Copy code examples for integration into your applications
Monitor API performance through the analytics dashboard

Code Examples

JavaScript

// Get all data
fetch('https://your-api-endpoint.com/data')
  .then(response => response.json())
  .then(data => console.log(data));

// Get data with filtering
fetch('https://your-api-endpoint.com/data?department=Engineering&limit=5')
  .then(response => response.json())
  .then(data => console.log(data));
                    

Python

import requests

# Get all data
response = requests.get('https://your-api-endpoint.com/data')
data = response.json()
print(data)

# Get data with filtering
params = {'department': 'Engineering', 'limit': 5}
response = requests.get('https://your-api-endpoint.com/data', params=params)
data = response.json()
print(data)
                    

cURL

# Get all data
curl -X GET "https://your-api-endpoint.com/data"

# Get data with pagination
curl -X GET "https://your-api-endpoint.com/data?limit=10&offset=0"

# Filter data
curl -X GET "https://your-api-endpoint.com/data?department=Engineering"
                    