Building RESTful APIs in CodeIgniter 4: Complete Guide

Codeigniter

Sep 03, 2025

Building RESTful APIs has become an essential skill for modern web developers, and CodeIgniter 4 provides an excellent platform for creating robust, scalable APIs. With its lightweight architecture, powerful features, and modern PHP standards support, CodeIgniter has evolved into a developer-friendly framework that excels at API development.

Table of Contents

RESTful APIs serve as the backbone of modern web applications, mobile apps, and microservices architectures. They enable seamless communication between different systems using standard HTTP methods and protocols. This comprehensive guide will walk you through every aspect of building professional-grade REST APIs in CodeIgniter 4, from basic setup to advanced security implementations.

What is a RESTful API?

A RESTful API (Representational State Transfer) is an architectural style for designing web services that uses HTTP methods to perform CRUD (Create, Read, Update, Delete) operations. RESTful APIs are stateless, meaning each request contains all the information needed to process it, and they rely on standard HTTP protocols for communication.

Key Characteristics of RESTful APIs

Statelessness: Each request is independent and contains all necessary information
Uniform Interface: Consistent URL structure and HTTP methods
Resource-Based: URLs represent resources, not actions
Multiple Representations: Support for JSON, XML, or other formats

HTTP Methods and Their Functions

RESTful APIs utilize standard HTTP methods for different operations:

GET: Retrieve data from the server
POST: Create new resources
PUT: Update existing resources completely
PATCH: Partially update resources
DELETE: Remove resources from the server

Why Choose CodeIgniter for API Development?

CodeIgniter 4 offers several compelling advantages for API development:

Performance and Efficiency

CodeIgniter is renowned for its lightweight footprint and exceptional performance. The framework’s minimal resource requirements make it ideal for high-traffic APIs that need to handle numerous concurrent requests efficiently.

Modern PHP Standards

CodeIgniter 4 supports modern PHP standards, including PSR-4 autoloading, namespaces, and PHP 7.4+ features. This ensures your APIs are built on a solid, future-proof foundation.

Built-in API Features

The framework includes native support for:

ResourceController: Simplified RESTful controller creation
JSON response formatting: Built-in methods for API responses
Request validation: Comprehensive input validation system
Database abstraction: Secure database interactions

Flexible Architecture

CodeIgniter’s MVC architecture promotes clean code organization, making APIs easier to maintain and scale. The framework’s modular approach allows developers to include only necessary components.

Setting Up CodeIgniter

Prerequisites

Before beginning, ensure your development environment meets these requirements:

PHP 7.4 or higher
Composer for dependency management
Web server (Apache, Nginx, or built-in PHP server)
Database (MySQL, PostgreSQL, SQLite, etc.)
Development environment (XAMPP, WAMP, or similar)

Installation

Install CodeIgniter 4

composer create-project codeigniter4/appstarter restful-api

Navigate to the project directory:

cd restful-api

Set Up the Base URL Open the .env file and configure the app.baseURL:
```
app.baseURL = 'http://localhost:8080/'
```
Start the Development Server
```
php spark serve
```
Visit http://localhost:8080 to confirm the installation.

Creating a RESTful API

Step 1: Enable RESTful Routing

CodeIgniter 4 provides a powerful routing system that supports RESTful resource routing. Open app/Config/Routes.php and add:
```
$routes->resource('products');
```
The resource method automatically generates RESTful routes for the Products controller:
- GET /products – Fetch all products.
- GET /products/{id} – Fetch a single product.
- POST /products – Create a new product.
- PUT /products/{id} – Update an existing product.
- DELETE /products/{id} – Delete a product.

Step 2: Create the Products Controller

Run the following command to create a RESTful controller. This creates a controller that extends ResourceController, providing built-in REST functionality.
```
php spark make:controller Products --restful
```

Open app/Controllers/Products.php and implement the methods:

namespace App\Controllers;

use CodeIgniter\RESTful\ResourceController;

class Products extends ResourceController
{
    protected $modelName = 'App\Models\Product';
    protected $format    = 'json';

    public function index()
    {
        return $this->respond($this->model->findAll());
    }

    public function show($id = null)
    {
        $data = $this->model->find($id);
        if (!$data) {
            return $this->failNotFound('Product not found');
        }
        return $this->respond($data);
    }

    public function create()
    {
        $input = $this->request->getPost();
        if (!$this->model->insert($input)) {
            return $this->failValidationErrors($this->model->errors());
        }
        return $this->respondCreated(['id' => $this->model->insertID()]);
    }

    public function update($id = null)
    {
        $input = $this->request->getRawInput();
        if (!$this->model->update($id, $input)) {
            return $this->failValidationErrors($this->model->errors());
        }
        return $this->respond(['message' => 'Product updated successfully']);
    }

    public function delete($id = null)
    {
        if (!$this->model->delete($id)) {
            return $this->failNotFound('Product not found');
        }
        return $this->respondDeleted(['message' => 'Product deleted successfully']);
    }
}

Step 3: Create the Product Model

Run the following command to create the model:
```
php spark make:model Product
```

Open app/Models/Product.php and define the model:

namespace App\Models;

use CodeIgniter\Model;

class Product extends Model
{
    protected $table      = 'products';
    protected $primaryKey = 'id';
    protected $allowedFields = ['name', 'description', 'price'];
    protected $validationRules = [
        'name' => 'required|min_length[3]',
        'price' => 'required|decimal',
    ];
}

Step 4: Create the Database Table

Create a migration file:

php spark make:migration CreateProductsTable

Define the table schema in the migration file:

public function up()
{
    $this->forge->addField([
        'id' => [
            'type'           => 'INT',
            'constraint'     => 5,
            'unsigned'       => true,
            'auto_increment' => true,
        ],
        'name' => [
            'type'       => 'VARCHAR',
            'constraint' => '100',
        ],
        'description' => [
            'type' => 'TEXT',
        ],
        'price' => [
            'type' => 'DECIMAL',
            'constraint' => '10,2',
        ],
        'created_at' => [
            'type' => 'DATETIME',
            'null' => true,
        ],
        'updated_at' => [
            'type' => 'DATETIME',
            'null' => true,
        ],
    ]);
    $this->forge->addKey('id', true);
    $this->forge->createTable('products');
}

public function down()
{
    $this->forge->dropTable('products');
}

Run the migration:
```
php spark migrate
```

Testing the API

You can test your API endpoints using tools like Postman or cURL. Example cURL commands:

Fetch all products:

curl -X GET http://localhost:8080/products

Create a new product:

curl -X POST http://localhost:8080/products -d "name=Sample Product&price=99.99"

Update a product:

curl -X PUT http://localhost:8080/products/1 -d "name=Updated Product&price=149.99"

Delete a product:

curl -X DELETE http://localhost:8080/products/1

Conclusion

Building RESTful APIs in CodeIgniter 4 provides developers with a powerful, flexible platform for creating modern web services. This comprehensive guide has covered everything from basic setup to advanced security implementations, performance optimization, and testing strategies.

Key takeaways from this guide include:

Security First: Always implement proper authentication, input validation, and security measures
Performance Optimization: Use caching, database optimization, and efficient query design
Testing is Essential: Implement comprehensive unit and integration tests
Documentation Matters: Maintain clear API documentation using tools like Swagger
Follow Best Practices: Adhere to REST principles and modern development practices

CodeIgniter 4’s combination of simplicity, performance, and modern PHP features makes it an excellent choice for API development. Whether you’re building a simple CRUD API or a complex microservices architecture, CodeIgniter provides the tools and flexibility needed to create robust, scalable solutions.

The framework’s active community, comprehensive documentation, and continuous development ensure that your APIs will remain maintainable and up-to-date with current web standards. By following the practices outlined in this guide, you’ll be well-equipped to build professional-grade REST APIs that can handle the demands of modern web applications.

Remember to always prioritize security, performance, and maintainability in your Restful API development process. Regular testing, monitoring, and documentation updates will ensure your Restful APIs continue to serve their intended purpose effectively as your application grows and evolves.

Blog