Idempotency keys for safe retries in Rest API

Introduction

Idempotency keys help make sure that when you send the same request multiple times, it only happens once. This stops mistakes like double payments or duplicate orders.

When a user clicks a button multiple times by accident and you want to avoid repeating the action.

When network problems cause a request to be sent again and you want to prevent duplicate processing.

When your system processes payments or orders and you want to ensure each is done only once.

When building APIs that clients might retry requests automatically.

When you want to keep your system safe from accidental repeated actions.

Syntax

Rest API

POST /api/orders HTTP/1.1
Idempotency-Key: unique-key-123
Content-Type: application/json

{
  "item": "book",
  "quantity": 1
}

The Idempotency-Key is a unique string sent in the request header.

The server uses this key to remember the request and avoid doing the same action twice.

Examples

Client sends a payment request with a unique idempotency key.

Rest API

POST /api/payments HTTP/1.1
Idempotency-Key: abc123
Content-Type: application/json

{
  "amount": 100
}

If the client sends the same request again with the same key, the server will not charge twice.

Rest API

POST /api/payments HTTP/1.1
Idempotency-Key: abc123
Content-Type: application/json

{
  "amount": 100
}

If no idempotency key is sent, the server treats each request as new and may process duplicates.

Rest API

POST /api/orders HTTP/1.1
Content-Type: application/json

{
  "item": "pen",
  "quantity": 2
}

Sample Program

This program creates a simple API that accepts orders with an Idempotency-Key header.

If the same key is sent again, it returns the saved response instead of creating a new order.

Rest API

from flask import Flask, request, jsonify

app = Flask(__name__)

# Store processed idempotency keys and their responses
processed_requests = {}

@app.route('/api/orders', methods=['POST'])
def create_order():
    idempotency_key = request.headers.get('Idempotency-Key')
    if not idempotency_key:
        return jsonify({'error': 'Idempotency-Key header missing'}), 400

    if idempotency_key in processed_requests:
        # Return the previous response to avoid duplicate processing
        return jsonify(processed_requests[idempotency_key])

    data = request.get_json()
    item = data.get('item')
    quantity = data.get('quantity')

    # Simulate order creation
    order_id = len(processed_requests) + 1
    response = {
        'order_id': order_id,
        'item': item,
        'quantity': quantity,
        'status': 'created'
    }

    # Save response with idempotency key
    processed_requests[idempotency_key] = response

    return jsonify(response)

if __name__ == '__main__':
    app.run(debug=True)

Important Notes

Time complexity: Checking and storing keys is usually O(1) with a hash map.

Space complexity: Stores keys and responses, so memory grows with unique requests.

Common mistake: Forgetting to require or check the Idempotency-Key header, which defeats the purpose.

Use idempotency keys when you want safe retries; use other methods like transactions for different guarantees.

Summary

Idempotency keys prevent duplicate actions by making repeated requests safe.

They work by sending a unique key with each request that the server remembers.

This is very useful for payments, orders, and any action that should happen only once.

Practice

1. What is the main purpose of using an idempotency key in REST APIs?

easy

A. To speed up the server response time

B. To prevent duplicate processing of the same request

C. To encrypt the request data

D. To authenticate the user

Solution

1. Step 1: Understand idempotency key concept

   An idempotency key is a unique identifier sent with a request to ensure the server processes it only once.

2. Step 2: Identify the main purpose

   This prevents duplicate actions like double payments or repeated orders if the client retries the request.

3. Final Answer:

   To prevent duplicate processing of the same request -> Option B

4. Quick Check:

   Idempotency key = prevent duplicates [OK]

Hint: Idempotency keys stop repeated actions safely [OK]

Common Mistakes:

• Confusing idempotency key with authentication token
• Thinking it speeds up response time
• Assuming it encrypts data

2. Which HTTP header is commonly used to send an idempotency key in a REST API request?

easy

A. Idempotency-Key

B. Cache-Control

C. Content-Type

D. Authorization

Solution

1. Step 1: Recall standard header for idempotency

   The standard practice is to send the unique idempotency key in the Idempotency-Key HTTP header.

2. Step 2: Differentiate from other headers

   Authorization is for credentials, Content-Type defines data format, and Cache-Control manages caching.

3. Final Answer:

   Idempotency-Key -> Option A

4. Quick Check:

   Idempotency key header = Idempotency-Key [OK]

Hint: Idempotency keys go in Idempotency-Key header [OK]

Common Mistakes:

• Using Authorization header for idempotency key
• Confusing Content-Type with idempotency key
• Sending key in request body instead of header

3. Consider this simplified server logic for handling POST requests with idempotency keys:

stored_keys = {}

def handle_request(idempotency_key, data):
    if idempotency_key in stored_keys:
        return stored_keys[idempotency_key]
    response = process_data(data)
    stored_keys[idempotency_key] = response
    return response

# Client sends:
print(handle_request('abc123', 'order1'))
print(handle_request('abc123', 'order1'))
print(handle_request('xyz789', 'order2'))

What will be the output?

medium

A. None, None, None

B. process_data output for order1, None, process_data output for order2

C. process_data output for order1, process_data output for order2, process_data output for order2

D. process_data output for order1, process_data output for order1, process_data output for order2

Solution

1. Step 1: Analyze first call with key 'abc123'

   Key not in stored_keys, so process_data('order1') runs, result saved and returned.

2. Step 2: Analyze second call with same key 'abc123'

   Key found, stored response returned without reprocessing.

3. Step 3: Analyze third call with new key 'xyz789'

   Key not found, process_data('order2') runs, result saved and returned.

4. Final Answer:

   process_data output for order1, process_data output for order1, process_data output for order2 -> Option D

5. Quick Check:

   Repeated key returns cached response [OK]

Hint: Repeated keys return cached response, new keys process data [OK]

Common Mistakes:

• Assuming second call reprocesses data
• Confusing keys and responses
• Thinking None is returned on repeats

4. A developer wrote this code snippet to handle idempotent POST requests:

cache = {}
def post_request(key, data):
    if key not in cache:
        process(data)
    return cache[key]

What is the bug in this code?

medium

A. It never stores the processed result in cache

B. It processes data twice for the same key

C. It raises an error if key is missing

D. It uses the wrong HTTP method

Solution

1. Step 1: Check caching logic

   The code checks if key not in cache, then calls process(data), but never saves the result in cache.

2. Step 2: Identify consequence

   Since cache[key] is never set, returning cache[key] will cause a KeyError or return None incorrectly.

3. Final Answer:

   It never stores the processed result in cache -> Option A

4. Quick Check:

   Missing cache storage causes errors [OK]

Hint: Always save processed result in cache before returning [OK]

Common Mistakes:

• Assuming process(data) stores result automatically
• Ignoring missing cache assignment
• Thinking HTTP method affects caching here

5. You are designing a payment API that uses idempotency keys to avoid duplicate charges. Which approach best ensures safe retries without charging twice if the client resends the same request due to a timeout?

hard

A. Ignore the idempotency key and process every request independently

B. Reject any request with an idempotency key that was seen before

C. Store the payment result linked to the idempotency key and return it on repeated requests

D. Process the payment again but log a warning for duplicate keys

Solution

1. Step 1: Understand safe retry requirements

   Safe retries mean the client can resend the same request without causing duplicate charges.

2. Step 2: Evaluate options

   Store the payment result linked to the idempotency key and return it on repeated requests stores the payment result linked to the key and returns it on repeats, preventing double charges. Ignore the idempotency key and process every request independently processes every request, risking duplicates. Reject any request with an idempotency key that was seen before rejects repeats, which may cause client errors. Process the payment again but log a warning for duplicate keys processes again, causing duplicates.

3. Final Answer:

   Store the payment result linked to the idempotency key and return it on repeated requests -> Option C

4. Quick Check:

   Store and reuse result for idempotency [OK]

Hint: Save and reuse payment result by key to avoid duplicates [OK]

Common Mistakes:

• Rejecting repeated keys causing client errors
• Processing duplicates causing double charges
• Logging warnings but still charging twice