Food Standards Agency SDKs & Libraries: Official & Community (2026)

SDKs overview

The Food Standards Agency (FSA), a non-ministerial government department of the United Kingdom, provides public APIs for developers to access food-related data. These APIs cover areas such as food hygiene ratings, allergen and intolerance information, and food incident data. While the FSA primarily offers direct API access with comprehensive FSA API documentation, several Software Development Kits (SDKs) and client libraries have emerged to simplify integration.

SDKs typically encapsulate the complexities of HTTP requests, response parsing, and error handling, allowing developers to interact with the API using native language constructs. This can reduce development time and potential errors. For instance, rather than manually constructing a URL and parsing a JSON response, an SDK might offer a method like fsa.getHygieneRating(establishmentId) that returns a structured object.

The FSA's approach to developer experience focuses on providing clear API specifications, often in formats like OpenAPI Specification, which can be used to generate client libraries automatically. OpenAPI, formerly known as Swagger Specification, defines a standard, language-agnostic interface to REST APIs, which allows both humans and computers to discover and understand the capabilities of the service without access to source code or additional documentation OpenAPI Specification documentation.

For developers, the availability of SDKs and libraries means a quicker path to integration. These tools are particularly beneficial for applications that frequently query FSA data, such as consumer-facing apps displaying hygiene ratings or internal systems monitoring food safety trends. The FSA's official data portal serves as the central hub for discovering available datasets and API endpoints.

Official SDKs by language

As of late 2024, the Food Standards Agency primarily provides direct API access and comprehensive documentation rather than maintaining a suite of official, language-specific SDKs. Their focus is on a well-documented API reference that supports various programming languages through standard HTTP client libraries. The official guidance emphasizes using standard web request libraries available in most programming environments, such as requests in Python, fetch in JavaScript, or HttpClient in C#. This approach allows developers flexibility in their technology stack.

However, the FSA's commitment to open data and clear API specifications facilitates the creation of client libraries. The absence of officially maintained SDKs does not preclude their existence; instead, it shifts the responsibility for development and maintenance to the community or individual projects. Developers are encouraged to consult the FSA API reference for the most up-to-date endpoint details, request formats, and response structures, which are critical for building or using any client library effectively.

While direct official SDKs are not provided, developers can often use tools that generate client code from OpenAPI specifications. The FSA API documentation typically provides enough detail to support such generation. Below is a conceptual table outlining how official SDKs might be structured if they were provided, demonstrating common properties:

Installation

Since the Food Standards Agency does not provide official language-specific SDKs, installation typically involves setting up standard HTTP client libraries in your chosen programming language. These libraries are usually available through package managers specific to each language ecosystem.

Python

For Python, the requests library is a common choice for making HTTP requests. It can be installed using pip:

pip install requests

JavaScript (Node.js/Browser)

In Node.js environments, node-fetch (to mimic browser's fetch API) or axios are popular. For browser-based applications, the native fetch API is often sufficient.

Using node-fetch (for Node.js):

npm install node-fetch

Using axios (for Node.js or browser):

npm install axios

PHP

For PHP, Guzzle is a widely used HTTP client. It is installed via Composer:

composer require guzzlehttp/guzzle

Ruby

In Ruby, the standard library includes Net::HTTP. For a more user-friendly experience, the httparty gem is often preferred:

gem install httparty

Java

For Java, popular choices include OkHttp or Apache HttpClient. If using Maven, add to your pom.xml (example for OkHttp):

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.9.3</version>
</dependency>

After installing your preferred HTTP client, you will interact directly with the FSA API endpoints as described in their official documentation.

Quickstart example

This quickstart demonstrates how to fetch food hygiene ratings for establishments using a standard HTTP client library in Python. This example directly interacts with the Food Hygiene Rating Scheme API, which is one of the core APIs provided by the FSA.

Python Quickstart: Fetching Hygiene Ratings

First, ensure you have the requests library installed (pip install requests).

import requests
import json

# Base URL for the Food Hygiene Rating Scheme API
BASE_URL = "https://api.ratings.food.gov.uk/establishments"

# Headers required by the FSA API
HEADERS = {
    "x-api-version": "2", # Specify API version
    "Accept": "application/json" # Request JSON response
}

def get_hygiene_ratings(name=None, postcode=None, local_authority_id=None, page_size=10, page_number=1):
    """
    Fetches food hygiene ratings based on search criteria.
    Args:
        name (str): Part of the establishment name.
        postcode (str): Part of the establishment postcode.
        local_authority_id (int): ID of the local authority.
        page_size (int): Number of results per page.
        page_number (int): The page number to retrieve.
    Returns:
        dict: JSON response containing establishment data, or None if an error occurs.
    """
    params = {
        "name": name,
        "postcode": postcode,
        "localAuthorityId": local_authority_id,
        "pageSize": page_size,
        "pageNumber": page_number
    }
    
    # Filter out None values from params
    params = {k: v for k, v in params.items() if v is not None}

    try:
        response = requests.get(BASE_URL, headers=HEADERS, params=params)
        response.raise_for_status() # Raise an HTTPError for bad responses (4xx or 5xx)
        return response.json()
    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err}")
    except requests.exceptions.ConnectionError as conn_err:
        print(f"Connection error occurred: {conn_err}")
    except requests.exceptions.Timeout as timeout_err:
        print(f"Timeout error occurred: {timeout_err}")
    except requests.exceptions.RequestException as req_err:
        print(f"An unexpected error occurred: {req_err}")
    return None

# --- Example Usage ---
if __name__ == "__main__":
    print("\n--- Searching for establishments by name (e.g., 'Pret A Manger') ---")
    pret_results = get_hygiene_ratings(name="Pret A Manger", page_size=3)
    if pret_results and pret_results.get('establishments'):
        print(f"Found {len(pret_results['establishments'])} establishments matching 'Pret A Manger':")
        for establishment in pret_results['establishments']:
            print(f"  - {establishment['BusinessName']}, {establishment['AddressLine1']}, {establishment['PostCode']} (Rating: {establishment['RatingValue']})")
    else:
        print("No 'Pret A Manger' establishments found or an error occurred.")

    print("\n--- Searching for establishments by postcode (e.g., 'SW1A 0AA') ---")
    postcode_results = get_hygiene_ratings(postcode="SW1A 0AA", page_size=2)
    if postcode_results and postcode_results.get('establishments'):
        print(f"Found {len(postcode_results['establishments'])} establishments in 'SW1A 0AA':")
        for establishment in postcode_results['establishments']:
            print(f"  - {establishment['BusinessName']}, {establishment['AddressLine1']} (Rating: {establishment['RatingValue']})")
    else:
        print("No establishments found for 'SW1A 0AA' or an error occurred.")

    print("\n--- Searching for establishments in a specific Local Authority (e.g., City of London, ID 125) ---")
    la_results = get_hygiene_ratings(local_authority_id=125, page_size=5)
    if la_results and la_results.get('establishments'):
        print(f"Found {len(la_results['establishments'])} establishments in City of London (ID 125):")
        for establishment in la_results['establishments']:
            print(f"  - {establishment['BusinessName']}, {establishment['AddressLine1']} (Rating: {establishment['RatingValue']})")
    else:
        print("No establishments found for Local Authority ID 125 or an error occurred.")

This example demonstrates how to construct requests with parameters and headers, handle responses, and iterate through the results. Developers would adapt this pattern for other FSA APIs, such as the Allergy and Intolerance API or the Food Incidents API, by changing the base URL and specific parameters as documented.

Community libraries

While the Food Standards Agency does not officially endorse or maintain language-specific SDKs, the open nature of their APIs and the demand for food safety data have led to the development of community-contributed libraries. These libraries often wrap the direct API calls in more idiomatic functions for specific programming languages, simplifying integration for developers.

Community libraries can vary widely in their maturity, maintenance status, and completeness. Developers considering using a community library should evaluate factors such as:

• Active Maintenance: Is the library regularly updated to reflect changes in the FSA API or to fix bugs?
• Documentation: Does the library provide clear installation instructions, usage examples, and API coverage?
• Community Support: Is there an active community (e.g., GitHub issues, forums) for assistance?
• Feature Completeness: Does the library cover all the FSA API endpoints and functionalities required for the project?
• Error Handling: How does the library manage API errors, rate limits, and network issues?

Common platforms for discovering community-contributed libraries include GitHub, language-specific package repositories (e.g., PyPI for Python, npm for JavaScript), and developer forums. A search on these platforms for terms like "FSA API Python" or "Food Standards Agency Node.js client" may yield relevant results.

As an example, a hypothetical community Python library might encapsulate the functionality shown in the quickstart into a class:

# Conceptual example of a community Python library

import requests

class FSARatingsClient:
    def __init__(self, api_version="2"):
        self._base_url = "https://api.ratings.food.gov.uk/establishments"
        self._headers = {
            "x-api-version": api_version,
            "Accept": "application/json"
        }

    def get_establishments(self, **kwargs):
        params = {k: v for k, v in kwargs.items() if v is not None}
        try:
            response = requests.get(self._base_url, headers=self._headers, params=params)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"API request failed: {e}")
            return None

# Usage example
if __name__ == "__main__":
    client = FSARatingsClient()
    data = client.get_establishments(name="Costa Coffee", postcode="EC2", pageNumber=1, pageSize=5)
    if data and data.get('establishments'):
        for est in data['establishments']:
            print(f"{est['BusinessName']} - Rating: {est['RatingValue']}")

This pattern demonstrates how a community library typically offers a higher-level abstraction, making the API more accessible to developers familiar with the language's conventions. Developers are advised to review the source code and documentation of any third-party library before integrating it into production systems.