---
title: "Look up any ingredient, and find out what goes with it — Tiny Plates"
description: "New Tiny Plates API endpoints resolve ingredient names in any language, return allergens, density and substitutions, and count what each ingredient pairs with."
url: "https://www.tinyplates.dev/blog/ingredient-lookup-and-pairings"
---

# Look up any ingredient, and find out what goes with it

Three new endpoints: resolve ingredient names, look one up, and see what it's cooked with.

By [Chris Artmann](https://www.tinyplates.dev/about) · 13 November 2026

People don't write ingredients the way a database stores them. One recipe says "scallions". Another says "spring onions". A Swedish one says "kycklinglår" and means chicken thighs. If you want to build anything on top of ingredients, you first need to know they're the same thing.

So we've added three new endpoints to the Tiny Plates API. One turns names into ingredients. One tells you everything we know about an ingredient. And one tells you what it's usually cooked with. They all work on the free plan.

Let's start with names. Send `/ingredients/resolve` a comma-separated list, written however your users write them:

```bash
curl 'https://api.tinyplates.dev/ingredients/resolve?names=scallions,boneless%20skinless%20chicken%20thighs,kycklingl%C3%A5r,cebolla,unicorn%20dust' \
  -H 'Authorization: Bearer rd_your_api_key'

```

```json
{
  "ingredients": [
    { "id": "spring-onion", "name": "spring onion", "query": "scallions" },
    { "id": "chicken-thigh", "name": "chicken thigh", "query": "boneless-skinless-chicken-thighs" },
    { "id": "chicken-thigh", "name": "chicken thigh", "query": "kycklinglår" },
    { "id": "onion", "name": "onion", "query": "cebolla" }
  ],
  "unknown": ["unicorn-dust"]
}

```

Scallions are spring onions. The long chicken line and the Swedish one land on the same id. Spanish onion is just onion. We match on every spelling we've seen in real recipes, in English, Swedish and Spanish.

Look at `unknown`, too. When a name matches nothing, we tell you so. We don't hand back the closest-sounding ingredient and hope for the best. A wrong match is worse than no match, especially once allergies are involved. You can ask the user, or leave it out.

Once you have an id, `/ingredients/:id` gives you the full picture:

```bash
curl 'https://api.tinyplates.dev/ingredients/double-cream' \
  -H 'Authorization: Bearer rd_your_api_key'

```

```json
{
  "ingredient": {
    "id": "double-cream",
    "name": "double cream",
    "aliases": { "en": ["double cream"], "sv": ["vispgrädde", "mellangrädde", "grädde"] },
    "allergens": { "milk": true, "eggs": false, "wheat": false, "...": "..." },
    "dietary": { "vegetarian": true, "vegan": false, "glutenFree": true, "dairyFree": false, "pescatarian": true },
    "density": 0.994,
    "pourable": true,
    "staple": false,
    "recipeCount": 10,
    "substitutions": [
      { "ingredient": "coconut cream", "ratio": 1, "caution": "Adds a clear coconut flavour, which suits a curry and not a custard." },
      { "ingredient": "evaporated milk", "ratio": 1, "caution": "Will not whip." }
    ]
  }
}

```

That's a lot in one call. You get the same 16 allergens we put on every recipe, and the diets it suits. You get the density in grams per millilitre, so you can turn cups into grams. We only include it when the number is well known. You learn whether it pours, so a converter knows to keep it as a volume. You see whether it's a staple most kitchens already have. And you get swaps, each with a short warning about when they won't work.

Some ingredients also have a `parent`. Chicken thigh's parent is `chicken`. Fresh cilantro's is `cilantro`. That's handy when a shopping list or a filter should treat them as the same food.

## What goes with basil?

The third endpoint is our favourite. `/ingredients/:id/pairings` looks at the recipes that use an ingredient and counts what else shows up next to it:

```bash
curl 'https://api.tinyplates.dev/ingredients/basil/pairings?limit=5' \
  -H 'Authorization: Bearer rd_your_api_key'

```

```json
{
  "ingredient": { "id": "basil", "name": "basil" },
  "recipeCount": 216,
  "pairings": [
    { "id": "garlic", "name": "garlic", "recipeCount": 114, "share": 0.528 },
    { "id": "butter", "name": "butter", "recipeCount": 38, "share": 0.176 },
    { "id": "parmesan", "name": "parmesan", "recipeCount": 35, "share": 0.162 },
    { "id": "tomato", "name": "tomato", "recipeCount": 34, "share": 0.157 },
    { "id": "egg", "name": "egg", "recipeCount": 33, "share": 0.153 }
  ]
}

```

Garlic shows up in more than half of the basil recipes. Then parmesan and tomato, which won't surprise anyone who has eaten pasta. These aren't from a flavour chart someone wrote down. They're counted from real recipes, so they follow how people actually cook.

Chicken thighs tell a different story. Garlic is in 72% of them, then butter, chicken broth, soy sauce and honey. That's a sticky glazed thigh hiding in the data.

Salt, pepper, oil, sugar, flour and water are left out by default. Otherwise they'd top every list and tell you nothing. Add `staples=true` if you want them back. `limit` takes 1 to 50.

Put the three together and some nice things fall out. A user types "a bunch of basil and some leftover chicken thighs". Resolve the names, look up the pairings, and suggest what to buy to turn it into a meal. Then send the ids to `/pantry` to find the actual recipe. You could build a "what goes with this?" button on an ingredient page. Or a pantry app that warns about milk before someone adds double cream to their list. Or a converter that knows a cup of cream weighs about 235 grams.

Agents get all of this too. The [Tiny Plates MCP server](https://www.tinyplates.dev/docs/mcp) has three new tools: `resolve_ingredients`, `get_ingredient` and `get_ingredient_pairings`. Ask your assistant "what should I cook with this basil?" and it can answer from real recipes instead of guessing.

One small change came along with this. The full ingredient list at `/ingredients` now needs a Business plan, like the `/recipes` list. If you used it to look up names, `/ingredients/resolve` is the better tool for that, and it's free.

The docs have every field: [resolve ingredients](https://www.tinyplates.dev/docs/api/resolve-ingredients), [get an ingredient](https://www.tinyplates.dev/docs/api/get-ingredient) and [ingredient pairings](https://www.tinyplates.dev/docs/api/ingredient-pairings). We'd love to see what you make with them.