# Korean Food Nutrition Database API - MFDS 식품영양성분 Calories (`elabstudio/korea-food-nutrition`) Actor

Official Korean food nutrition data from MFDS (식품영양성분DB): calories, protein, fat, carbs, sugars, sodium and 150+ nutrients for Korean dishes, packaged products and ingredients. English or Korean search.

- **URL**: https://apify.com/elabstudio/korea-food-nutrition.md
- **Developed by:** [E:LAB STUDIO](https://apify.com/elabstudio) (community)
- **Categories:** Developer tools, AI
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 foods

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Korean Food Nutrition Database API: MFDS Calories & Nutrients (식품영양성분)

Get **official nutrition facts for Korean food** as clean, English JSON / CSV / Excel: calories, protein, fat, carbohydrates, sugars, fiber, sodium and **150+ nutrients** (vitamins, minerals, fatty acids, amino acids) for Korean dishes like bibimbap and kimchi jjigae, for packaged products like Shin Ramyun, and for raw ingredients.

The data comes from the **Food Nutrition Database of the Ministry of Food and Drug Safety (MFDS, 식품의약품안전처)**, the official Korean government source, published on the public data portal data.go.kr. It covers about **347,000 foods**: roughly 9,000 generic reference foods and 338,000 branded products, updated continuously.

Search in **English or Korean**. Common English words (kimchi, bibimbap, tteokbokki, bulgogi, ramen, tofu...) are translated to Korean automatically, and every food name comes back with a romanized version.

### What you can use it for

- **Diet, fitness and calorie-tracking apps**: add Korean dishes and Korean supermarket products that global food databases miss.
- **Meal planning and recipe nutrition**: per-100 g values plus serving and package weights.
- **AI assistants and LLM tools**: a reliable, structured source for "how many calories are in tteokbokki?" questions.
- **Health research**: sodium, sugar and fat content of Korean diets, by category or brand.
- **Food import and product research**: compare packaged products by maker, category, import status and country of origin.

### Input

| Field | Example | Notes |
|---|---|---|
| `foodNames` | `["bibimbap", "김치찌개", "신라면"]` | Korean names, or common English names from the built-in dictionary (~130 words). The source matches names that contain the text. Empty = list by category or maker only. |
| `maxItemsPerQuery` | `10` | Popular words match hundreds of foods ("김치" matches ~6,900). `0` = no limit. |
| `foodType` | `reference` | `all`, `reference` (generic averages, 품목대표) or `branded` (packaged products, 상용제품). |
| `dataGroups` | `["dish"]` | Optional: `dish` (prepared dishes, 음식), `processed` (packaged foods, 가공식품), `raw` (ingredients, 원재료성). |
| `category` | `면 및 만두류` | Optional major category, exact Korean name as in the source. |
| `maker` | `농심` | Optional manufacturer, partial match. |
| `includeAllNutrients` | `true` | Adds a `nutrients` object with every reported nutrient, its English name and unit. |
| `maxItems` | `1000` | Stop after N foods. `0` = no limit. |

Example: generic nutrition values for popular Korean dishes

```json
{ "foodNames": ["bibimbap", "bulgogi", "tteokbokki", "kimchi jjigae"], "foodType": "reference", "maxItemsPerQuery": 5 }
```

Example: every Nongshim product in the database

```json
{ "maker": "농심", "foodType": "branded", "maxItemsPerQuery": 0, "maxItems": 0 }
```

### Output example

Main nutrients are columns; all nutrients are in `nutrients` (shortened here). Amounts are per `nutrient_basis` (usually 100 g or 100 ml).

```json
{
  "food_code": "D101-018000000-0001",
  "name_ko": "비빔밥",
  "name_romanized": "Bibimbap",
  "data_group": "Prepared dish (음식)",
  "food_type": "Reference food (품목대표)",
  "category_ko": "밥류",
  "nutrient_basis": "100g",
  "food_weight": "450.000g",
  "energy_kcal": 142,
  "protein_g": 6.86,
  "fat_g": 4.32,
  "carbohydrate_g": 18.84,
  "sugars_g": 0.05,
  "dietary_fiber_g": 2,
  "sodium_mg": 232,
  "saturated_fat_g": 0.95,
  "trans_fat_g": 0.06,
  "cholesterol_mg": 42.26,
  "nutrients": {
    "energy_kcal": { "name": "Energy", "value": 142, "unit": "kcal" },
    "vitamin_a_ug_rae": { "name": "Vitamin A (RAE)", "value": 73, "unit": "µg RAE" },
    "retinol_ug": { "name": "Retinol", "value": 9, "unit": "µg" }
  },
  "data_source_ko": "식품의약품안전처",
  "data_method_ko": "분석",
  "data_created": "2018-12-31",
  "data_updated": "2026-10-13",
  "source": "MFDS Food Nutrition Database via data.go.kr (식품의약품안전처_식품영양성분DB정보)",
  "query": "bibimbap"
}
```

A branded product row also has `maker_ko` (e.g. "(주)농심"), `maker_romanized`, `item_report_no`, `imported`, `origin_country_ko` and `serving_reference` (the official reference serving, e.g. "유탕면(용기) 80g").

### Pricing

Pay per result: **$1.00 per 1,000 foods**, all nutrients included. A small start fee per run applies. You can set a maximum cost per run and the Actor stops when it is reached.

### FAQ

**How many calories are in bibimbap, according to official Korean data?**
The MFDS reference value is 142 kcal per 100 g (a 450 g bowl is about 640 kcal). Several variants exist (dolsot, yukhoe, by survey year), so you get each one with its code and date.

**Can I search in English?**
Yes for common Korean dishes and ingredients (kimchi, bibimbap, japchae, samgyeopsal, ramen, tofu, soju...). Anything else: use the Korean name. The log tells you when an English word is not in the dictionary.

**Why are there several rows with the same name?**
The database keeps separate entries per data source and survey (for example values per 100 g and per 100 ml, or different years). Use `food_code`, `nutrient_basis` and `data_created` to choose, or filter with `foodType: "reference"`.

**Are values per serving or per 100 g?**
Per `nutrient_basis`, which is almost always 100 g or 100 ml. Use `food_weight` (package or dish weight) or `serving_reference` to convert.

**Does it include allergens or ingredient lists?**
No. This source covers nutrition composition only.

**Do I need a data.go.kr API key?**
No. The Actor uses its own access to the official API.

### Source and license

Data: **식품의약품안전처_식품영양성분DB정보** (Ministry of Food and Drug Safety, Food Nutrition Database), published on the Korean public data portal [data.go.kr](https://www.data.go.kr/data/15127578/openapi.do) with license scope **"이용허락범위 제한 없음" (no restriction on use, commercial use allowed)**. Every row names its source. Values are reproduced as published; this Actor is not affiliated with MFDS. Nutrition data is informational and not medical advice.

# Actor input Schema

## `foodNames` (type: `array`):

Korean names (김치, 비빔밥, 신라면) or common English names (kimchi, bibimbap, tteokbokki, bulgogi). The source matches names that contain the text. Leave empty to list foods by category or maker only.

## `maxItemsPerQuery` (type: `integer`):

Popular words match hundreds of products ("김치" matches ~6,900). 0 = no limit.

## `foodType` (type: `string`):

Reference foods are generic averages (e.g. 'Bibimbap'), about 9,000 items. Branded products are packaged foods with a maker, about 338,000 items.

## `dataGroups` (type: `array`):

Optional filter: prepared dishes (음식), processed / packaged foods (가공식품), raw ingredients (원재료성). Empty = all.

## `category` (type: `string`):

Optional major category name exactly as in the source, e.g. 면 및 만두류, 밥류, 찌개 및 전골류, 과자류·빵류 또는 떡류, 음료류.

## `maker` (type: `string`):

Optional manufacturer name, partial match, e.g. 농심, 오뚜기, CJ제일제당.

## `includeAllNutrients` (type: `boolean`):

Adds a `nutrients` object with every reported nutrient (vitamins, minerals, fatty acids, amino acids, sugars) with name and unit. Main nutrients are always included as columns.

## `maxItems` (type: `integer`):

Stop after N foods. 0 = no limit.

## Actor input object example

```json
{
  "foodNames": [
    "bibimbap",
    "김치찌개"
  ],
  "maxItemsPerQuery": 10,
  "foodType": "all",
  "includeAllNutrients": true,
  "maxItems": 1000
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `all` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "foodNames": [
        "bibimbap",
        "김치찌개"
    ],
    "maxItemsPerQuery": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("elabstudio/korea-food-nutrition").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "foodNames": [
        "bibimbap",
        "김치찌개",
    ],
    "maxItemsPerQuery": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("elabstudio/korea-food-nutrition").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "foodNames": [
    "bibimbap",
    "김치찌개"
  ],
  "maxItemsPerQuery": 10
}' |
apify call elabstudio/korea-food-nutrition --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,elabstudio/korea-food-nutrition"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/C2LRHFcCloxeB5K1c/builds/LSaIzjFMhquEfAQ0C/openapi.json