Difference between HTTP and REST API servers - ObjectWire.org

What is an HTTP Server?

An HTTP server handles requests and responses using the Hypertext Transfer Protocol, the foundation of web communication. It listens for client connections, processes incoming data, and sends back content like web pages, images, or files. Popular examples include Apache, Nginx, and Node.js's built-in HTTP module.

Key Point: HTTP is a protocol (a set of rules), not a specific type of server. Any server that communicates using HTTP is an "HTTP server."

What is a REST API Server?

A REST API server is a specific type of HTTP server that follows REST (Representational State Transfer) architectural principles. It provides programmatic access to resources through standardized HTTP methods and structured data formats (usually JSON).

Important: All REST API servers are HTTP servers, but not all HTTP servers are REST API servers. REST is an architectural style built on top of HTTP.

Key Differences

1. Purpose & Use Case

HTTP Server

Serves any content over HTTP: websites, files, images, videos. Can handle any type of request-response pattern.

REST API Server

Specifically designed for programmatic access to data and services. Focuses on CRUD operations and resource manipulation.

2. Response Format

HTTP Server

Returns any content type: HTML, CSS, JavaScript, images, PDFs, etc. Content-Type varies by resource.

REST API Server

Typically returns structured data in JSON or XML format. Consistent, machine-readable responses.

3. URL Structure

HTTP Server

Can be anything:

/about.html
/contact-us
/images/logo.png

REST API Server

Resource-oriented:

/api/users
/api/users/123
/api/posts/456/comments

4. HTTP Methods Usage

HTTP Server

Often uses just GET and POST. Methods may not follow semantic meaning.

REST API Server

Uses HTTP methods semantically:

• GET - Read resources
• POST - Create resources
• PUT/PATCH - Update resources
• DELETE - Remove resources

Code Examples

Basic HTTP Server (Node.js)

const http = require('http');
const fs = require('fs');

const server = http.createServer((req, res) => {
  if (req.url === '/') {
    // Serve HTML page
    const html = fs.readFileSync('index.html');
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.end(html);
  } else if (req.url === '/style.css') {
    // Serve CSS file
    const css = fs.readFileSync('style.css');
    res.writeHead(200, { 'Content-Type': 'text/css' });
    res.end(css);
  }
});

server.listen(3000);

REST API Server (Express)

const express = require('express');
const app = express();

app.use(express.json());

// GET - Read all users
app.get('/api/users', (req, res) => {
  res.json({ users: [...] });
});

// GET - Read specific user
app.get('/api/users/:id', (req, res) => {
  const user = findUser(req.params.id);
  res.json({ user });
});

// POST - Create new user
app.post('/api/users', (req, res) => {
  const newUser = createUser(req.body);
  res.status(201).json({ user: newUser });
});

// PUT - Update user
app.put('/api/users/:id', (req, res) => {
  const updated = updateUser(req.params.id, req.body);
  res.json({ user: updated });
});

// DELETE - Remove user
app.delete('/api/users/:id', (req, res) => {
  deleteUser(req.params.id);
  res.status(204).end();
});

app.listen(3000);

REST API Principles

For an HTTP server to be a true REST API, it should follow these principles:

1. Stateless

Each request contains all information needed. Server doesn't store client state between requests.

2. Resource-Based

URLs represent resources (nouns), not actions (verbs). Use HTTP methods for actions.

3. Uniform Interface

Consistent patterns across all endpoints. Predictable structure and behavior.

4. Client-Server Separation

Client and server evolve independently. Interface remains stable.

When to Use Each

Use a Traditional HTTP Server When:

✓ Serving a traditional website with HTML pages
✓ Delivering static files (images, CSS, JavaScript)
✓ Building server-rendered applications (SSR)
✓ Simple file serving or content delivery

Use a REST API Server When:

✓ Building backends for mobile apps
✓ Creating APIs for SPA (React, Vue, Angular)
✓ Enabling third-party integrations
✓ Microservices architecture
✓ Data-driven applications requiring CRUD operations

Summary

The main difference is architectural: HTTP servers can serve any content in any way, while REST API servers follow specific architectural constraints to provide standardized, programmatic access to resources.

• HTTP Server: General-purpose web server using HTTP protocol
• REST API Server: Specialized HTTP server following REST principles
• Both use HTTP, but REST adds structure and conventions
• Modern applications often combine both (serve website + provide API)