Food Standards Agency Getting Started: API Integration (2026)

Getting started overview

Accessing data from the Food Standards Agency (FSA) typically involves interacting with their public APIs. These APIs provide programmatic access to information such as food hygiene ratings, allergen data, and records of food incidents. Unlike many commercial APIs, most FSA APIs do not require API keys or other authentication mechanisms for accessing public datasets, which streamlines the initial setup process. The primary steps for getting started include identifying the relevant API, understanding its documentation, and constructing your first API request.

The FSA's API offerings are designed to support various applications, from public information services to internal data analysis tools. Developers can utilize these APIs to integrate food safety information directly into their platforms or applications. The data provided is subject to updates, and developers should consult the official Food Standards Agency data documentation for the most current information regarding data schemas, endpoints, and usage policies.

To begin, consider which specific FSA dataset aligns with your project's requirements. For example, developers focusing on consumer information might prioritize the Food Hygiene Rating Scheme API, while those building supply chain tools might explore the Food Incidents API.

Create an account and get keys

For most public datasets offered by the Food Standards Agency, creating an account or obtaining API keys is not required. The FSA aims to make public food safety data broadly accessible without barriers for developers and researchers. This approach eliminates a common prerequisite for API integration, allowing immediate access to many of their information services.

Specifically, the FSA's documented APIs, such as the Food Hygiene Rating Scheme API and the Allergy and Intolerance API, are typically open access. This means developers can directly make requests to the API endpoints as documented, provided they adhere to any fair usage policies that may be implicitly or explicitly stated. Without the need for authentication, the process of obtaining credentials is bypassed, simplifying the initial development phase.

Developers accustomed to authenticating with services like Stripe Payments or AWS Key Management Service will find the FSA's public API model distinct due to its unauthenticated nature. While this simplifies access, developers should still familiarize themselves with the FSA data guidelines to ensure responsible and efficient use of the data, especially concerning data freshness and acceptable request rates.

If, in the future, the FSA introduces APIs that require authentication for specific restricted datasets or premium services, information on account creation and key management would be provided directly on their official data portal. As of 2026, for the core public APIs, this step is generally not applicable.

Your first request

To make your first request to a Food Standards Agency API, you will typically interact with a RESTful endpoint that returns data in JSON format. Given that most FSA APIs do not require authentication, you can directly query an endpoint. This example demonstrates how to retrieve local authority data using the Food Hygiene Rating Scheme API.

First, identify the base URL for the API you intend to use. For the Food Hygiene Rating Scheme API, the base URL is generally https://api.ratings.food.gov.uk/. You can find specific endpoint details, such as the /authorities endpoint for local authorities, in the FSA API Reference.

Example Request: Retrieve Local Authorities

This curl command retrieves a list of local authorities associated with food hygiene ratings. The x-api-version header is critical for specifying the API version, ensuring compatibility and access to the intended data structure.

curl -X GET \
  'https://api.ratings.food.gov.uk/authorities' \
  -H 'Accept: application/json' \
  -H 'x-api-version: 2'

Upon execution, this request will return a JSON array containing objects representing different local authorities, each with details such as their ID, name, and related data points. A successful response will typically have an HTTP status code 200 OK.

Example JSON Response (truncated)

{
  "authorities": [
    {
      "LocalAuthorityId": 1,
      "LocalAuthorityIdCode": "1",
      "Name": "Aberdeen City",
      "EstablishmentCount": 1888,
      "SchemeType": 1,
      "NewRatingPending": true,
      "RegionName": "Scotland",
      "Filename": "http://ratings.food.gov.uk/OpenDataFiles/FHRS2.xml",
      "LocalAuthorityWebSite": "http://www.aberdeencity.gov.uk",
      "LocalAuthorityEmailAddress": "[email protected]"
    },
    {
      "LocalAuthorityId": 2,
      "LocalAuthorityIdCode": "2",
      "Name": "Aberdeenshire",
      "EstablishmentCount": 2855,
      "SchemeType": 1,
      "NewRatingPending": false,
      "RegionName": "Scotland",
      "Filename": "http://ratings.food.gov.uk/OpenDataFiles/FHRS2.xml",
      "LocalAuthorityWebSite": "http://www.aberdeenshire.gov.uk",
      "LocalAuthorityEmailAddress": "[email protected]"
    }
  ],
  "meta": {
    "pageSize": 20,
    "pageNumber": 1,
    "totalResults": 394,
    "link": "/authorities?pageSize=20&pageNumber=1"
  }
}

This response structure provides metadata about the query and the list of authorities. You can then parse this JSON data within your application to extract specific information, such as the Name or LocalAuthorityWebSite for each authority.

Common next steps

After successfully making your initial API request to the Food Standards Agency, several common next steps can enhance your integration and application development:

1. Explore Additional Endpoints: The FSA APIs offer various endpoints beyond the initial example. For instance, the Food Hygiene Rating Scheme API allows querying for specific establishments, retrieving detailed hygiene information, and searching by postcode or business type. Consult the FSA API Reference to discover all available endpoints and parameters for the API you are using.
2. Implement Error Handling: While the first request might succeed, robust applications require comprehensive error handling. Familiarize yourself with common HTTP status codes (e.g., 400 Bad Request, 404 Not Found, 500 Internal Server Error) and how the FSA APIs convey error messages in their responses. Your code should gracefully manage these scenarios to provide a reliable user experience.
3. Manage Rate Limits: Although specific rate limits are not always prominently documented for all public FSA APIs, it is good practice to implement rate limiting or back-off strategies in your application to avoid overwhelming the API servers. High-volume requests in a short period may result in temporary blocking. Tools like AWS API Gateway's request throttling illustrate concepts that apply to client-side rate limit management.
4. Parse and Utilize Data: Effectively parsing the JSON responses is crucial. Depending on your programming language, you'll use libraries or built-in functions to deserialize the JSON into usable data structures. For example, in Python, you might use the json module; in JavaScript, JSON.parse(). Once parsed, integrate the data into your application's logic or display it to users.
5. Stay Updated: API providers, including the FSA, may update their APIs, introduce new versions, or deprecate old endpoints. Regularly check the Food Standards Agency data portal and related documentation for announcements, changes, or new datasets that could impact your integration or offer new opportunities.
6. Consider Data Storage and Caching: For applications that require frequent access to static or slow-changing data, consider implementing a caching strategy. Storing frequently requested data locally or in a cache can reduce API calls, improve application performance, and minimize dependency on external services.

Troubleshooting the first call

When your initial API call to the Food Standards Agency does not yield the expected results, consider the following troubleshooting steps:

1. Verify the Endpoint URL: Double-check that the endpoint URL is precisely correct, including any subpaths. Typos in the URL are a common cause of 404 Not Found errors. Refer to the FSA API Reference for the exact endpoint.
2. Check HTTP Method: Ensure you are using the correct HTTP method (e.g., GET for retrieving data). Sending a POST request to a GET-only endpoint will result in an error, typically a 405 Method Not Allowed.
3. Inspect Request Headers: Confirm that required headers, such as Accept: application/json and x-api-version: 2 (if specified for the API version), are included and correctly formatted. Missing or incorrect headers can lead to various errors, including content type negotiation issues or API version mismatches.
4. Examine the Response Body and Status Code: Even if the request appears to fail, always inspect the HTTP status code and the response body. The status code provides a high-level indication of the problem (e.g., 400 for client-side errors, 500 for server-side errors), and the response body often contains a more detailed error message from the API.
5. Review API Documentation for Parameters: If you are including query parameters (e.g., ?name=value), verify that they are spelled correctly, have valid values, and are in the format expected by the API. Incorrect parameters can lead to 400 Bad Request errors or unexpected results.
6. Network Connectivity: Ensure your development environment has stable internet access and is not blocked by a firewall or proxy from reaching the FSA API domains.
7. Tool Configuration: If using a tool like Postman, Insomnia, or a specific programming library, ensure it is configured correctly to send all parts of the request (URL, headers, body, method).
8. CORS Issues (for browser-based applications): If developing a browser-based application, Cross-Origin Resource Sharing (CORS) policies can prevent requests from succeeding. Verify that the FSA API supports CORS for your origin, or rely on a proxy server to circumvent browser-imposed restrictions. The Mozilla Developer Network's CORS guide provides comprehensive details on understanding and mitigating these issues.

By systematically checking these points, you can often diagnose and resolve issues with your initial API calls to the Food Standards Agency.