AI-powered · Launching 2026

Stop writing
ingredient
parsers.

RecipeParse turns any messy ingredient string into clean, structured JSON — quantities, units, names, prep state, confidence scores. One API call. Done.

Get early access Read the docs →

100 free credits on launch

No credit card

Instant API key

POST /api/v1/parse/ingredients200 OK

REQUEST · ingredients_raw

"2¼ cups plain flour",

"1 tsp baking soda",

"115g unsalted butter, melted"

RESPONSE · parsed_ingredients

“2¼ cups plain flour”0.97

nameflour

quantity2.25

unitcup

prepnull

“1 tsp baking soda”0.99

namebaking_soda

quantity1

unittsp

prepnull

“115g unsalted butter, melted”0.98

namebutter

quantity115

unitg

prepmelted

Built for food-tech teams

97%

avg confidence score

<1s

median parse time

regex to maintain

100

free credits on launch

 # TODO: handle "2¼ cups" — breaks regex
# TODO: "115g" vs "115 g" vs "115 grams"
# TODO: "unsalted butter, melted" — which part is the name?
# TODO: "a handful of" — what unit is THAT?? 🔥

def parse_ingredient(text):
    # 3 weeks of regex hell
    patterns = [
        r'(\d+)\s*(cup|cups|tsp|tbsp)',
        r'(\d+(?:\.\d+)?)\s*(g|kg|oz|lb)',
        # ... 200 more patterns, all fragile
    ]
    # Confidence: unknown
    # Unit tests: 0
    # Tech debt: infinite

The Problem

Every food team rebuilds the same parser — badly.

Weeks of engineering, wasted
Teams spend 2–6 weeks on fragile regex parsers that break on a unicode fraction or a mixed-unit ingredient.
A new recipe source means a new parser
Formats vary wildly across sources. A parser built for one site fails silently on another — forever.
Bad data = bad product
Grocery lists, nutrition tracking, meal planning — every downstream feature depends on clean data you never actually get.
Three internal parsers that disagree
Scale-ups end up with conflicting parsers across teams. QA becomes a permanent nightmare.

How it works

Three steps from raw text to production data.

Send your raw ingredient strings

POST an array of ingredient strings — exactly as they appear. Fractions, unicode, parenthetical notes — all fine.

POST /api/v1/parse/ingredients
Authorization: Bearer rp_live_...

"2¼ cups plain flour"
"115g unsalted butter, melted"

AI extracts & validates the structure

Our model identifies quantities, units, names, and prep states. A validator normalises units and scores confidence.

1. Send to AI model
2. Validate + normalise
3. Generate canonical IDs
4. Score confidence per item
5. Check SHA-256 cache

Use clean JSON in your app

Get back structured data with canonical IDs, normalised units, confidence scores, and optional product matches.

"name": "flour",
"quantity": 2.25,
"unit": "cup",
"confidence": 0.97

Features

Everything your food app needs to handle ingredients properly.

Quantity extraction

Handles integers, decimals, fractions (¼ ⅓ ¾), unicode quantities, and written numbers. 2¼ becomes 2.25 — reliably.

Unit normalisation

Converts "tsp", "teaspoon", "teaspoons" to one canonical unit. Full metric and imperial, including mixed-unit strings.

Canonical ingredient IDs

Every ingredient gets a consistent snake_case ID. unsalted_butter, every time. Consistent across every call.

Preparation state

"melted", "finely chopped", "at room temperature" — all split into a dedicated preparation field. Ready for your UI.

Confidence scoring

Every parsed ingredient gets a 0–1 confidence score. Flag low-confidence results for human review. Always know when to trust the data.

Step ↔ ingredient linking

Links method steps back to parsed ingredients with character-level spans. Know exactly where "butter" appears in instructions.

Product enrichment

Match ingredients against a branded product catalogue with fuzzy matching — ranked by confidence. Built for grocery integrations.

SHA-256 smart caching

Identical ingredient lists return instantly at zero cost. Keyed by a hash of the sorted ingredient array — zero stale-data risk.

vs. the alternatives

We're the only API purpose-built for ingredient parsing.

General food APIs treat parsing as an afterthought. We built the whole thing around it.

Feature	RecipeParse	Spoonacular	Edamam	Zestful
Ingredient-only parsing	✓	Partial	Partial	✓
Confidence scores	✓	✗	✗	✗
Step ↔ ingredient linking	✓	✗	✗	✗
Product enrichment	✓	✗	✗	✗
SHA-256 smart caching	✓	✗	✗	✗
Developer-friendly terms	✓	Partial	Partial	✓
Starting price	$0 / month	$29 / month	$29 / month	$79 / month

Pricing

Start free. Upgrade when you're ready.

Simple, transparent pricing. No contracts, no lock-in. Your parsed data is yours forever.

FREE

$0/ month

Try it with no commitment.

✓5 parse credits / month
✓5 enrich credits / month
✓10 requests / minute
✓API key management
✓Usage dashboard

Get started free

Common questions.

What counts as one parse credit?

One call to POST /api/v1/parse/ingredients consumes one parse credit, regardless of how many ingredients are in the array. Cached responses cost zero credits.

Can I keep and store the parsed data?

Yes. Unlike Spoonacular and Edamam, RecipeParse uses developer-friendly terms. You own your parsed output. Store it, transform it, build commercial products on top of it.

What ingredient formats does it handle?

All common formats: integers, decimals, unicode fractions (¼ ⅓ ¾), written numbers ("one"), mixed units ("1 lb 4 oz"), ranges ("2–3 cups"), and preparation descriptors ("finely chopped").

Is there an SDK?

Python and JavaScript/TypeScript SDKs launch with the API. Both are open-source. You can also use the REST API directly with any HTTP client — standard JSON with Bearer token auth.

How accurate is the parsing?

Our model returns a per-ingredient confidence score (0–1). In testing, 94%+ of parses score above 0.9. Filter on confidence to decide when to flag for human review.

What's the product enrichment add-on?

Product enrichment matches parsed ingredients against a branded catalogue with fuzzy matching, returning ranked candidates. Useful for grocery-list and shopping-cart integrations.

Stop writingingredientparsers.