Spoonacular API for Recipes, Food Products, and Nutrition

Overview

The Spoonacular API provides developers with access to a large dataset of food-related information, including recipes, ingredients, and nutritional data. This API is designed for applications requiring features such as advanced recipe search, meal planning, dietary analysis, and food product information retrieval. Spoonacular offers various endpoints to query recipes by ingredients, dietary restrictions, cuisine, or nutritional content. It also supports complex use cases like ingredient parsing from natural language and generating meal plans based on user preferences and health goals.

Developers commonly integrate Spoonacular into recipe-sharing platforms, meal preparation services, health and fitness trackers, and e-commerce sites focused on food products. For instance, a mobile application could use the API to suggest recipes to users based on ingredients they have on hand, while a nutrition tracking platform might leverage it to automatically calculate macronutrients and micronutrients for specific dishes. The API's capabilities extend to handling dietary restrictions, allergens, and specific health-related queries, allowing for tailored user experiences. For example, the Analyze Recipe Instructions endpoint can break down cooking steps into structured data, which assists in building interactive recipe guides. According to Google Trends data, interest in food APIs, including Spoonacular, has shown consistent search volume, indicating ongoing developer demand in the food technology sector.

The API's free tier allows for initial development and testing, providing 9,000 requests per month and up to 150 requests daily. This enables developers to prototype applications without an upfront financial commitment. Paid plans scale based on request volume, catering to applications with increasing user bases or high data retrieval needs. The documentation includes example requests and responses in multiple programming languages, aiming to streamline the integration process. Spoonacular's focus on providing granular food data positions it as a resource for building detailed and personalized food-centric digital products.

Key features

• Recipe Search and Filtering: Extensive search capabilities for recipes based on ingredients, cuisine, diet, intolerances, and nutritional values. Includes endpoints for random recipes, similar recipes, and complex ingredient searches.
• Nutrition Analysis: Provides detailed nutritional information for recipes, ingredients, and food products. Can analyze a recipe's nutritional content, interpret ingredient lists, and calculate macronutrients and micronutrients.
• Meal Planning: Offers features to generate meal plans for specific timeframes, considering dietary preferences, caloric goals, and available ingredients. This includes adding, removing, and retrieving items from a user's meal plan.
• Food Product Search: Allows searching for packaged food products by name, barcode (UPC), or specific attributes, providing details like ingredients, nutrition facts, and images.
• Ingredient Parsing: Can parse natural language ingredient strings into structured data, identifying quantity, unit, and exact ingredient. This helps in standardizing user-inputted recipe data.
• Recipe Instructions Analysis: Converts raw recipe instructions into a step-by-step format, identifying equipment, ingredients, and length for each step.
• Shopping List Generation: Based on planned meals or recipes, the API can generate a consolidated shopping list with ingredient quantities.

Pricing

Spoonacular offers a free tier for development and testing, alongside several paid subscription plans that scale with request volume. Pricing tiers are designed to accommodate projects from individual developers to larger applications with higher usage requirements.

Pricing accurate as of 2026-05-08. For the most current pricing details and any additional plan options, refer to the official Spoonacular API pricing page.

Common integrations

Spoonacular is typically integrated into applications requiring food data. While there are no official SDKs, it is commonly accessed via standard HTTP client libraries in various programming languages.

• Python: Developers use libraries like HTTPX or requests to make RESTful API calls to Spoonacular endpoints.
• JavaScript/Node.js: Frontend applications or Node.js backends often utilize fetch or Axios for API requests.
• PHP: Guzzle HTTP client is a common choice for PHP applications interacting with external APIs.
• Mobile Apps (iOS/Android): Native mobile development involves using platform-specific networking libraries (e.g., URLSession in Swift, OkHttp in Kotlin/Java) to integrate Spoonacular data.

Alternatives

Developers seeking food data APIs have several alternatives, each with distinct features and pricing models:

• Edamam: Offers APIs for recipe search, nutrition analysis, and food database lookup, often with a focus on detailed dietary data.
• Yummly: Provides APIs for recipe search and discovery, ingredient analysis, and often includes features for recipe personalization.
• TheMealDB: A community-driven database focused on recipes, offering a free API for basic recipe search and details, though with a smaller dataset than commercial alternatives.

Getting started

To begin using the Spoonacular API, you typically need an API key, which can be obtained by signing up on their website. Once you have your API key, you can make HTTP requests to their endpoints. The following Python example demonstrates how to find recipes by ingredients using the requests library.

import requests
import json

API_KEY = "YOUR_API_KEY"  # Replace with your actual Spoonacular API key

def search_recipes_by_ingredients(ingredients, number=5):
    url = "https://api.spoonacular.com/recipes/findByIngredients"
    params = {
        "ingredients": ",".join(ingredients),
        "number": number,
        "apiKey": API_KEY,
        "ranking": 1,  # Maximize used ingredients
        "ignorePantry": True # Ignore pantry items for more relevant results
    }
    try:
        response = requests.get(url, 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

if __name__ == "__main__":
    # Example usage: Find recipes using chicken, broccoli, and onion
    my_ingredients = ["chicken", "broccoli", "onion"]
    recipes = search_recipes_by_ingredients(my_ingredients, number=3)

    if recipes:
        print(f"Found {len(recipes)} recipes with {', '.join(my_ingredients)}:")
        for recipe in recipes:
            print(f"- {recipe['title']} (ID: {recipe['id']})")
            print(f"  Used ingredients: {', '.join([ing['name'] for ing in recipe['usedIngredients']])}")
            print(f"  Missed ingredients: {', '.join([ing['name'] for ing in recipe['missedIngredients']])}")
    else:
        print("No recipes found or an error occurred.")

This script defines a function search_recipes_by_ingredients that constructs a GET request to the Spoonacular API. It includes error handling for common HTTP issues. The if __name__ == "__main__" block demonstrates how to call this function with a list of ingredients and then prints out the titles and ingredient details of the retrieved recipes. Further details on API endpoints and parameters are available in the Spoonacular API reference documentation.