Making Partial Updates with PATCH Requests in Python

Nov 17, 2023 ยท 7 min read

PATCH requests allow developers to partially update resources via APIs. Instead of replacing the entire resource like PUT requests, PATCH enables you to selectively modify specific attributes.

For example, you may want to update a user's email address without changing anything else about their profile. Or you may want to toggle a single boolean field like "email_notifications: true" without affecting other settings.

These types of partial updates are the perfect use case for PATCH. In this article, we'll dive deep into making PATCH requests in Python using the requests module.

Overview of PATCH Requests

The HTTP PATCH method is used to apply partial modifications to a resource. With PATCH, you send a set of instructions for how to modify the resource instead of sending the full resource representation.

Some key characteristics of PATCH requests:

  • Partial update: Only the changed attributes are sent, not the whole resource. This avoids overhead when making minor changes.
  • Json patch documents: The PATCH request body contains JSON with update operations like "replace", "remove", etc.
  • Idempotent: Same request can be repeated without unintended side effects.
  • Non-atomic: Individual operations can fail without rolling back other ops.
  • So in summary, PATCH allows partial, targeted updates to an existing resource using JSON patch docs.

    Why Use PATCH Instead of POST or PUT?

    There are a couple primary advantages of using PATCH versus other HTTP methods:

    More efficient updates: Only send changed data, not the full resource representation every time. Saves on network bandwidth.

    Idempotent changes: Repeating a PATCH request will make the same update without adverse effects. Retries are safe if requests fail.

    Fine-grained control: Update specific nested fields instead of full resources.

    POST and PUT require sending the entire resource which is less efficient for partial updates. PATCH has become the preferred method for making selective changes to resources via REST APIs.

    Making Requests in Python with Requests

    Before we dive into the specifics of PATCH, let's quickly cover how to make requests in Python.

    The excellent Requests library makes it simple to interact with APIs from Python scripts and applications.

    To start, install Requests:

    pip install requests

    Then import Requests and use the get() method to send a GET request:

    import requests
    response = requests.get('<>')

    This will return a Response object with the API response data. We can access the content like:


    We can also include headers, URL parameters, json data and more. We'll use these basic requests while exploring PATCH next.

    Making a PATCH Request in Python

    Now that we've covered the basics of Requests, let's look at how to make PATCH requests specifically.

    The Requests module has a handy patch() method that handles all the details of sending PATCH requests:

    response = requests.patch(url, data=data, headers=headers)

    Let's break this down:

  • url - The URL of the resource to PATCH
  • data - Dict, bytes, or file-like object with the JSON patch document
  • headers - Dict of HTTP headers to include
  • The patch() method will encode and send the request properly, and return a Response object like the get() method.

    Simple PATCH Example

    Let's see a simple example:

    import requests
    url = '<>'
    data = {'email': ''}
    response = requests.patch(url, json=data)

    Here we are sending a PATCH request to /users/123 to modify the email field. The request contains a JSON body with the update operation.

    We can print the status code and content like before:


    This will send a properly formatted PATCH request and hopefully return status code 200 OK!

    Adding Request Headers

    We likely need to include special headers in our PATCH request like Content-Type and authentication. Here is an example adding headers:

    headers = {
        'Content-Type': 'application/json-patch+json',
        'Authorization': 'Bearer xxx'
    response = requests.patch(url, json=data, headers=headers)

    The important ones for PATCH are:

  • Content-Type: Set to application/json-patch+json
  • Authorization: Include auth token if required
  • Handling JSON Response Data

    Many APIs will return JSON-encoded data in the response content. We can load the JSON data using the json() method:

    json_data = response.json()

    This parsed and validated the JSON return and gives us a nice dict or list of Python data to work with.

    We may also need to set headers = {'Accept': 'application/json'} to ask for JSON if the API provides other formats.

    Patching Specific Resource Fields

    The key power of PATCH requests is the ability to modify specific fields within a resource. Let's look at how field selection works.

    When creating our JSON patch document, we simply specify the path to the field we want to update.

    For example, to update just the first_name of a user we would have:

        {"op": "replace", "path": "/first_name", "value": "Jane"}

    The path indicates the field to replace, here /first_name. We can update nested attributes too like:

        {"op": "replace", "path": "/address/city", "value": "New York"}

    This makes it easy to modify individual attributes as needed!

    Using PATCH for Partial Updates

    Now that we understand the mechanics of PATCH requests in Python, let's explore some best practices for applying PATCH properly when modifying resources.

    PATCH works best for atomic, independent changes that don't require complex coordination. For example, updating a single field like an email address or boolean flag.

    You want to avoid patching multiple related fields that need to update together in a transaction. If you must modify related fields, use PUT to replace the full resource in one go.

    Some APIs also offer transactions to ensure all changes succeed or fail as a whole with rollbacks. This helps when patching multiple fields with interdependencies.

    Always review the API docs to understand if certain field updates need to happen in conjunction and if any transaction semantics or rollbacks are supported.

    Handling Failures and Retries

    Like any API request over the network, PATCH requests can fail randomly. It's important to include robust retry logic and error handling when patching resources.

    Here are some tips for handling failures:

  • Use try/except blocks to catch RequestException errors
  • Check for 400-500 level status codes
  • Implement exponential backoff for retries
  • Idempotency means retries are safe for PATCH
  • Handle race conditions if lacking transactions
  • With good error handling, your application can patch resources reliably.

    Recap and Best Practices

    To wrap up, here are some key takeaways:

  • Use PATCH to efficiently update individual resource fields
  • Send JSON patch documents listing update operations
  • Include required headers like Content-Type
  • Use error handling and retries to patch robustly
  • Review API docs to check for restrictions and transaction support
  • Prefer PATCH over PUT/POST for targeted changes
  • Following REST API best practices for making PATCH requests will ensure your application patches resources properly. The Requests library makes it easy to get started integrating PATCH operations into your Python codebase.

    Happy patching!

    Related Resources

  • Official Requests Documentation
  • Json Patch Standard RFC
  • REST API Design Best Practices
  • FAQ

    Here are some frequently asked questions about PATCH requests in Python:

    Q: What status codes should I expect from PATCH?

    A: 200 OK means the resource was successfully patched. 404 means the resource was not found. 400 can mean invalid JSON format or request. 401 is unauthorized.

    Q: How do I include authentication headers?

    A: Pass a dict with the header like headers={'Authorization': 'Bearer xxx'} to add any headers needed.

    Q: Can I send form-encoded data instead of JSON?

    A: Technically yes, but JSON is the standard format for patch docs. The API must support form-encoding for PATCH to work this way.

    Q: Should I check if fields exist before patching?

    A: Not strictly required, but can be useful validation to avoid errors. Use a GET request first to check the resource.

    Q: What libraries besides Requests can I use?

    A: urllib3, httplib, aiohttp, httpx, and others support PATCH. But Requests is likely the easiest to use.

    Browse by tags:

    Browse by language:

    The easiest way to do Web Scraping

    Get HTML from any page with a simple API call. We handle proxy rotation, browser identities, automatic retries, CAPTCHAs, JavaScript rendering, etc automatically for you

    Try ProxiesAPI for free

    curl ""

    <!doctype html>
        <title>Example Domain</title>
        <meta charset="utf-8" />
        <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
        <meta name="viewport" content="width=device-width, initial-scale=1" />


    Don't leave just yet!

    Enter your email below to claim your free API key: