The Complete Guide to API Communication Patterns: REST, GraphQL, WebSocket, gRPC, and More

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# Get all users
GET https://api.example.com/users
Response: 200 OK
[
  {"id": 1, "name": "Alice"},
  {"id": 2, "name": "Bob"}
]

# Get specific user
GET https://api.example.com/users/1
Response: 200 OK
{"id": 1, "name": "Alice", "email": "alice@example.com"}

# Create user
POST https://api.example.com/users
Body: {"name": "Charlie", "email": "charlie@example.com"}
Response: 201 Created
{"id": 3, "name": "Charlie", "email": "charlie@example.com"}

# Update user
PUT https://api.example.com/users/3
Body: {"name": "Charles", "email": "charlie@example.com"}
Response: 200 OK
{"id": 3, "name": "Charles", "email": "charlie@example.com"}

# Delete user
DELETE https://api.example.com/users/3
Response: 204 No Content

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Client specifies exactly what it needs
query {
  user(id: 123) {
    name
    email
    posts(limit: 5) {
      title
      createdAt
      comments(limit: 3) {
        author
        text
      }
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

{
  "data": {
    "user": {
      "name": "Alice",
      "email": "alice@example.com",
      "posts": [
        {
          "title": "Getting Started with GraphQL",
          "createdAt": "2025-01-15",
          "comments": [
            {"author": "Bob", "text": "Great post!"},
            {"author": "Charlie", "text": "Thanks for sharing"}
          ]
        }
      ]
    }
  }
}

1
2
3
4
5
6
7

# REST approach
response = requests.post('https://api.example.com/users',
                        json={'name': 'Alice', 'email': 'alice@example.com'})
user = response.json()

# RPC approach (looks like local function)
user = server.createUser(name='Alice', email='alice@example.com')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

syntax = "proto3";

service UserService {
  rpc GetUser(UserId) returns (User);
  rpc ListUsers(Empty) returns (stream User);  // Server streaming
  rpc CreateUser(stream UserData) returns (User);  // Client streaming
  rpc ChatStream(stream Message) returns (stream Message);  // Bidirectional
}

message UserId {
  int32 id = 1;
}

message User {
  int32 id = 1;
  string name = 2;
  string email = 3;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import grpc
from user_pb2 import UserId
from user_pb2_grpc import UserServiceStub

# Create channel
channel = grpc.insecure_channel('localhost:50051')
stub = UserServiceStub(channel)

# Call remote function (feels local!)
response = stub.GetUser(UserId(id=123))
print(f"User: {response.name}, {response.email}")

# Server streaming example
for user in stub.ListUsers(Empty()):
    print(f"User: {user.name}")

1
2
3
4
5
6
7
8

<?xml version="1.0"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
    <GetUser xmlns="http://example.com/users">
      <UserId>123</UserId>
    </GetUser>
  </soap:Body>
</soap:Envelope>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// Simple polling - check every 5 seconds
function pollStatus(jobId) {
  setInterval(async () => {
    const response = await fetch(`/api/jobs/${jobId}/status`);
    const data = await response.json();

    if (data.status === 'complete') {
      console.log('Job finished!');
      clearInterval(pollInterval);
    }
  }, 5000);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

async function longPoll() {
  while (true) {
    try {
      // Server holds this request open until data available
      const response = await fetch('/api/updates', {
        timeout: 30000  // 30 second timeout
      });

      const data = await response.json();
      handleUpdate(data);

      // Immediately reconnect
    } catch (error) {
      // On timeout or error, reconnect after delay
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// Create EventSource connection
const eventSource = new EventSource('/api/stream');

// Listen for messages
eventSource.onmessage = (event) => {
  const data = JSON.parse(event.data);
  console.log('Received:', data);
  updateDashboard(data);
};

// Handle connection events
eventSource.onopen = () => {
  console.log('Connection established');
};

eventSource.onerror = (error) => {
  console.error('Connection error:', error);
};

// Close when done
// eventSource.close();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import asyncio
import json

app = FastAPI()

async def event_generator():
    """Generate events to send to client"""
    while True:
        # Get data (from sensor, database, queue, etc.)
        data = {"temperature": get_temperature(), "timestamp": time.time()}

        # SSE format: "data: {json}\n\n"
        yield f"data: {json.dumps(data)}\n\n"

        await asyncio.sleep(1)  # Send update every second

@app.get("/api/stream")
async def stream():
    return StreamingResponse(
        event_generator(),
        media_type="text/event-stream"
    )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// Create WebSocket connection
const socket = new WebSocket('wss://example.com/chat');

// Connection opened
socket.addEventListener('open', (event) => {
  console.log('Connected to server');
  socket.send(JSON.stringify({type: 'join', room: 'general'}));
});

// Listen for messages from server
socket.addEventListener('message', (event) => {
  const data = JSON.parse(event.data);

  if (data.type === 'chat') {
    displayMessage(data.user, data.message);
  } else if (data.type === 'notification') {
    showNotification(data.message);
  }
});

// Send message to server
function sendMessage(text) {
  socket.send(JSON.stringify({
    type: 'chat',
    message: text
  }));
}

// Handle connection close
socket.addEventListener('close', (event) => {
  console.log('Disconnected from server');
  // Implement reconnection logic
});

// Handle errors
socket.addEventListener('error', (error) => {
  console.error('WebSocket error:', error);
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from typing import List

app = FastAPI()

# Store active connections
active_connections: List[WebSocket] = []

@app.websocket("/chat")
async def websocket_endpoint(websocket: WebSocket):
    # Accept connection
    await websocket.accept()
    active_connections.append(websocket)

    try:
        while True:
            # Receive message from client
            data = await websocket.receive_json()

            if data['type'] == 'chat':
                # Broadcast to all connected clients
                message = {
                    'type': 'chat',
                    'user': data['user'],
                    'message': data['message']
                }

                for connection in active_connections:
                    await connection.send_json(message)

    except WebSocketDisconnect:
        # Remove from active connections
        active_connections.remove(websocket)

        # Notify others
        for connection in active_connections:
            await connection.send_json({
                'type': 'notification',
                'message': 'User disconnected'
            })

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// Express.js endpoint to receive GitHub webhooks
app.post('/webhook/github', (req, res) => {
  const event = req.headers['x-github-event'];
  const payload = req.body;

  // Verify signature (security best practice)
  const signature = req.headers['x-hub-signature-256'];
  if (!verifySignature(signature, req.body)) {
    return res.status(401).send('Invalid signature');
  }

  // Handle different event types
  if (event === 'push') {
    console.log(`Push to ${payload.repository.name}`);
    console.log(`Commits: ${payload.commits.length}`);

    // Trigger CI/CD pipeline
    triggerBuild(payload.repository.name);

  } else if (event === 'pull_request') {
    console.log(`PR ${payload.action}: ${payload.pull_request.title}`);

    // Run tests, post status check
    runTests(payload.pull_request);
  }

  // Always return 200 OK to acknowledge receipt
  res.status(200).send('Webhook received');
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

const crypto = require('crypto');

// Verify webhook signature (example: GitHub)
function verifySignature(signature, body) {
  const secret = process.env.GITHUB_WEBHOOK_SECRET;
  const hmac = crypto.createHmac('sha256', secret);
  const digest = 'sha256=' + hmac.update(body).digest('hex');
  return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(digest));
}

// Implement idempotency (handle duplicate webhooks)
const processedWebhooks = new Set();

app.post('/webhook', (req, res) => {
  const webhookId = req.headers['x-webhook-id'];

  // Check if already processed
  if (processedWebhooks.has(webhookId)) {
    return res.status(200).send('Already processed');
  }

  // Process webhook
  handleWebhook(req.body);

  // Mark as processed
  processedWebhooks.add(webhookId);

  res.status(200).send('OK');
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

import pika
import json

# Producer: Send message to queue
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# Declare queue (creates if doesn't exist)
channel.queue_declare(queue='orders', durable=True)

# Send message
message = {
    'order_id': 12345,
    'customer_id': 789,
    'total': 99.99
}

channel.basic_publish(
    exchange='',
    routing_key='orders',
    body=json.dumps(message),
    properties=pika.BasicProperties(
        delivery_mode=2,  # Make message persistent
    )
)

print(f"Sent order {message['order_id']}")
connection.close()

# Consumer: Process messages from queue
def process_order(ch, method, properties, body):
    order = json.loads(body)
    print(f"Processing order {order['order_id']}")

    # Do work (update database, send email, etc.)
    process_payment(order)
    fulfill_order(order)

    # Acknowledge message (remove from queue)
    ch.basic_ack(delivery_tag=method.delivery_tag)

# Set up consumer
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='orders', durable=True)

# Process one message at a time (fair dispatch)
channel.basic_qos(prefetch_count=1)

# Start consuming
channel.basic_consume(queue='orders', on_message_callback=process_order)
print('Waiting for messages...')
channel.start_consuming()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import boto3
import json

sqs = boto3.client('sqs', region_name='us-east-1')
queue_url = 'https://sqs.us-east-1.amazonaws.com/123456789/my-queue'

# Send message
response = sqs.send_message(
    QueueUrl=queue_url,
    MessageBody=json.dumps({
        'event': 'user_registered',
        'user_id': 12345,
        'email': 'user@example.com'
    })
)

# Receive and process messages
while True:
    response = sqs.receive_message(
        QueueUrl=queue_url,
        MaxNumberOfMessages=10,
        WaitTimeSeconds=20  # Long polling
    )

    messages = response.get('Messages', [])

    for message in messages:
        body = json.loads(message['Body'])
        print(f"Processing: {body['event']}")

        # Process message
        handle_event(body)

        # Delete from queue (acknowledge)
        sqs.delete_message(
            QueueUrl=queue_url,
            ReceiptHandle=message['ReceiptHandle']
        )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import paho.mqtt.client as mqtt

# Publisher
client = mqtt.Client()
client.connect("mqtt.example.com", 1883)

# Publish temperature reading
client.publish("home/bedroom/temperature", "72.5")

# Subscriber
def on_message(client, userdata, message):
    print(f"Topic: {message.topic}")
    print(f"Value: {message.payload.decode()}")

client = mqtt.Client()
client.on_message = on_message
client.connect("mqtt.example.com", 1883)

# Subscribe to topic (supports wildcards)
client.subscribe("home/+/temperature")  # All rooms
client.subscribe("home/#")  # All topics under home/

client.loop_forever()