Gratis Makroreferenstabeller: Ladda ner komplett näringsdata i CSV och JSON

Oavsett om du bygger en näringsapp, genomför en forskningsstudie, coachar klienter eller bara vill ha ett pålitligt referensblad på skrivbordet, behöver du ren makrodata i ett format som du faktiskt kan arbeta med. Statliga databaser finns, men de är ofta omfattande, inkonsekventa och anpassade för byråkrater snarare än skapare.

Vi har sammanställt en uppsättning gratis makroreferenstabeller som täcker över 500 vanliga livsmedel med fullständiga makronutrienter. Data finns tillgänglig i både CSV- och JSON-format, redo att användas i ett kalkylblad, en databas, ett skript eller en applikation. Varje post har verifierats mot primära källor, och filerna är strukturerade så att du kan börja använda dem direkt utan behov av städning eller omvandling.

Denna sida täcker exakt vad som ingår i tabellerna, hur datan är strukturerad, hur du laddar den programatiskt och hur du kan bidra med korrigeringar om du hittar något som behöver uppdateras.

Vad Ingår

Makroreferenstabellerna innehåller 500+ av de mest konsumerade livsmedlen indelade i sju huvudkategorier. För varje livsmedelsartikel får du:

• Livsmedelsnamn — det standardiserade engelska namnet som används inom näringsvetenskap
• Kategori — en av sju övergripande kategorier (mer om dessa nedan)
• Underkategori — en mer specifik gruppering inom huvudkategorin
• Beskrivning av portionsstorlek — en lättförståelig portionsstorlek (t.ex. "1 medelstor banan", "1 kopp kokt")
• Portionsvikt i gram — gram motsvarigheten av den portionsstorleken
• Kalorier — total energi i kilokalorier (kcal)
• Protein — gram protein per portion
• Totalt fett — gram totalt fett per portion
• Mättat fett — gram mättat fett per portion
• Totala kolhydrater — gram totalt kolhydrater per portion
• Kostfiber — gram kostfiber per portion
• Socker — gram totalt socker per portion
• Natrium — milligram natrium per portion

Varje värde rapporteras per den angivna portionsstorleken, inte per 100 gram. Vi valde detta tillvägagångssätt eftersom portionsbaserad data är vad de flesta faktiskt behöver när de spårar måltider, bygger måltidsplaner eller visar näringsinformation i ett gränssnitt. Om du behöver värden per 100 g, är det enkelt att dela med portionsvikten och multiplicera med 100.

Tabellerna inkluderar inte mikronäringsämnen utöver natrium och fiber. För fullständiga mikronäringsprofiler (vitaminer, mineraler, aminosyror), se avsnittet om Nutrolas API i slutet av denna artikel — där finns den detaljerade datan.

Specifikationer för Dataformat

CSV-format

CSV-filen använder UTF-8-kodning med en rubrikrad. Fälten är kommaseparerade och textfält är inneslutna i citattecken. Här är hur strukturen ser ut:

food_name,category,subcategory,serving_description,serving_weight_g,calories_kcal,protein_g,total_fat_g,saturated_fat_g,total_carbs_g,fiber_g,sugar_g,sodium_mg
"Kycklingbröst, utan ben och skinn, kokt","Proteiner","Fjäderfä","1 bröst (170g)",170,284,53.4,6.2,1.7,0.0,0.0,0.0,126
"Atlantlax, kokt","Proteiner","Fisk & Skaldjur","1 filé (154g)",154,280,39.3,12.4,2.5,0.0,0.0,0.0,109
"Brunt ris, kokt","Korn & Stärkelse","Fullkorn","1 kopp (195g)",195,216,5.0,1.8,0.4,44.8,3.5,0.7,10
"Banana, rå","Frukter","Tropiska Frukter","1 medelstor (118g)",118,105,1.3,0.4,0.1,27.0,3.1,14.4,1

CSV-filen är kompatibel med Microsoft Excel, Google Sheets, LibreOffice Calc, Apple Numbers och vilket programmeringsspråk som helst med stöd för CSV-parsing. Ingen speciell konfiguration behövs — öppna filen så kommer den att tolkas korrekt.

JSON-format

JSON-filen innehåller en array av objekt, ett för varje livsmedelsartikel. Strukturen speglar CSV-fälten:

{
  "version": "1.4.0",
  "generated": "2026-03-12",
  "source": "Nutrola Macro Reference Tables",
  "record_count": 527,
  "foods": [
    {
      "food_name": "Kycklingbröst, utan ben och skinn, kokt",
      "category": "Proteiner",
      "subcategory": "Fjäderfä",
      "serving_description": "1 bröst (170g)",
      "serving_weight_g": 170,
      "nutrients": {
        "calories_kcal": 284,
        "protein_g": 53.4,
        "total_fat_g": 6.2,
        "saturated_fat_g": 1.7,
        "total_carbs_g": 0.0,
        "fiber_g": 0.0,
        "sugar_g": 0.0,
        "sodium_mg": 126
      }
    }
  ]
}

JSON-filen inkluderar metadatafält på översta nivån: en versionssträng för att spåra uppdateringar, genereringsdatum, källnamn och det totala antalet poster. Detta gör det enkelt att verifiera att du har den senaste versionen och att bygga logik för att kontrollera uppdateringar i dina applikationer.

Numeriska värden lagras som siffror, inte strängar. Null-värden förekommer inte — om ett näringsvärde är okänt, utesluts livsmedlet från datasetet istället för att inkluderas med saknad data. Detta var ett medvetet val för att hålla datan ren och undvika tysta fel i beräkningar.

Fältdeskriptioner

Här är en detaljerad sammanställning av varje fält, inklusive enheter, förväntade intervall och kantfall:

Fält	Typ	Enhet	Beskrivning
food_name	string	—	Standard engelskt namn. Inkluderar tillagningsmetod där det är relevant (t.ex. "kokt", "rå", "torkad").
category	string	—	En av sju övergripande kategorier. Se kategorisektionen nedan.
subcategory	string	—	En mer specifik gruppering. Till exempel, inom "Proteiner" hittar du "Fjäderfä", "Rött kött", "Fisk & Skaldjur", "Baljväxter" och "Ägg".
serving_description	string	—	En lättförståelig portionsstorlek. Inkluderar alltid gramvikten inom parentes.
serving_weight_g	number	gram	Den numeriska gramvikten av portionen. Heltalsvärden för de flesta artiklar, ett decimalvärde för artiklar där precision är viktigt.
calories_kcal	number	kcal	Total energi. Beräknad med hjälp av Atwater-systemet (4 kcal/g protein, 4 kcal/g kolhydrater, 9 kcal/g fett).
protein_g	number	gram	Totalt protein. En decimalplats precision.
total_fat_g	number	gram	Totalt fett inklusive mättat, enkelomättat och fleromättat.
saturated_fat_g	number	gram	Endast mättade fettsyror.
total_carbs_g	number	gram	Totala kolhydrater inklusive fiber och socker.
fiber_g	number	gram	Totalt kostfiber (lösligt + olösligt).
sugar_g	number	gram	Totalt socker (naturligt förekommande + tillsatt). Datasetet separerar inte tillsatt socker från naturligt socker.
sodium_mg	number	milligram	Natriumhalt. Observera att detta är milligram, inte gram, till skillnad från de andra näringsfälten.

Några anteckningar om precision: alla näringsvärden är avrundade till en decimalplats. Detta matchar precisionen i den underliggande källdata. Att rapportera fler decimaler skulle ge en falsk nivå av noggrannhet — livsmedelskomposition varierar naturligt med 5-15% beroende på odlingsförhållanden, djurart och tillagningsmetoder.

Livsmedelskategorier

De 500+ livsmedlen är organiserade i sju övergripande kategorier, var och en med flera underkategorier:

Proteiner

Cirka 95 poster som täcker fjäderfä (kycklingbröst, lår, kalkon, mald kalkon), rött kött (nötkött, malet nötkött med olika fetthalter, fläskkött, lamm), fisk och skaldjur (lax, tonfisk, räkor, torsk, tilapia, sardiner), ägg (hela, äggvita, scrambled) och växtbaserade proteiner (tofu, tempeh, seitan, edamame). Baljväxter som linser, kikärtor och svarta bönor ingår här snarare än i korn eftersom deras primära näringsroll är att leverera protein.

Korn och Stärkelse

Cirka 80 poster som täcker fullkorn (brunt ris, havre, quinoa, korn, bulgur), raffinerade korn (vitt ris, vitt bröd, pasta), stärkelsehaltiga grönsaker (potatis, sötpotatis, majs) och vanliga kornprodukter (tortillas, bagels, kex, couscous). Både kokta och torra värden ges för korn där distinktionen är viktig.

Frukter

Cirka 65 poster som täcker vanliga färska frukter (äpplen, bananer, apelsiner, jordgubbar, blåbär, druvor), tropiska frukter (mango, ananas, papaya, kiwi), torkade frukter (russin, dadlar, torkade aprikoser, tranbär) och frysta frukter. Alla färska fruktposter avser den råa, ätbara delen — frön, skal och kärnor utesluts från portionsvikten där det är tillämpligt.

Grönsaker

Cirka 85 poster som täcker bladgrönsaker (spenat, grönkål, romaine, ruccola), korsblommiga grönsaker (broccoli, blomkål, brysselkål, kål), rotfrukter (morötter, rödbetor, kålrot, rädisor), allium (lök, vitlök), nattskydd (tomater, paprika, aubergine) och andra vanliga grönsaker (gurka, selleri, zucchini, svamp, sparris). Både råa och kokta värden ges för grönsaker där tillagning avsevärt förändrar näringstätheten per portion.

Mejeriprodukter och Alternativ

Cirka 70 poster som täcker mjölk (hel, 2%, skummjölk och växtbaserade mjölkprodukter), yoghurt (grekisk, vanlig, smaksatt, växtbaserad), ost (cheddar, mozzarella, feta, keso, färskost, parmesan), smör, grädde och vanliga mejerialternativ (mandelmjölk, havremjölk, sojamjölk, kokosyoghurt). Växtbaserade mjölkprodukter och yoghurter grupperas här snarare än i en separat kategori eftersom användare vanligtvis väljer dem som direkta substitut.

Snacks och Bearbetade Livsmedel

Cirka 75 poster som täcker nötter och frön (mandlar, valnötter, jordnötter, chiafrön, linfrön, solrosfrön), nötterbutter (jordnötssmör, mandelsmör), vanliga snacks (pretzels, popcorn, granola-barer, proteinbarer, trail mix, chips, mörk choklad), pålägg och såser (hummus, guacamole, salsa, majonnäs, olivolja, honung) och andra vanligt spårade artiklar som proteinpulver och energibitar.

Drycker

Cirka 60 poster som täcker juicer (apelsinjuice, äppeljuice, tranbärsjuice), läskedrycker (cola, citron-lime soda, ingefära öl), sport- och energidrycker, kaffedrycker (svart kaffe, latte, cappuccino, mocha med olika mjölktyper), smoothie-baser, alkoholhaltiga drycker (öl, vin, sprit) och vanliga tillsatser (grädde, socker, smaksatta siraper). Vatten ingår inte eftersom det inte har något makronäringsinnehåll.

Använda Datan Programatiskt

Syftet med att tillhandahålla CSV- och JSON-format är att du kan ladda denna data direkt in i din kod. Här är fungerande exempel i Python och JavaScript.

Python: Ladda CSV

import csv

def load_macro_table(filepath):
    foods = []
    with open(filepath, newline='', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        for row in reader:
            # Konvertera numeriska fält från strängar
            for key in ['serving_weight_g', 'calories_kcal', 'protein_g',
                        'total_fat_g', 'saturated_fat_g', 'total_carbs_g',
                        'fiber_g', 'sugar_g', 'sodium_mg']:
                row[key] = float(row[key])
            foods.append(row)
    return foods

foods = load_macro_table('macro_reference_table.csv')

# Hitta alla livsmedel i en kategori
proteins = [f for f in foods if f['category'] == 'Proteiner']
print(f"Found {len(proteins)} protein sources")

# Hitta de livsmedel med högst protein per kalori
foods_sorted = sorted(foods, key=lambda f: f['protein_g'] / max(f['calories_kcal'], 1), reverse=True)
print("\nTop 10 foods by protein density (g protein per kcal):")
for f in foods_sorted[:10]:
    ratio = f['protein_g'] / f['calories_kcal']
    print(f"  {f['food_name']}: {ratio:.3f} g/kcal ({f['protein_g']}g protein, {f['calories_kcal']} kcal)")

Python: Ladda JSON

import json

def load_macro_json(filepath):
    with open(filepath, encoding='utf-8') as f:
        data = json.load(f)
    print(f"Loaded {data['record_count']} foods (version {data['version']})")
    return data['foods']

foods = load_macro_json('macro_reference_table.json')

# Bygg en uppslagsordbok efter livsmedelsnamn
lookup = {f['food_name'].lower(): f for f in foods}

# Snabb uppslagning
chicken = lookup.get('kycklingbröst, utan ben och skinn, kokt')
if chicken:
    n = chicken['nutrients']
    print(f"Kycklingbröst per portion ({chicken['serving_description']}):")
    print(f"  Kalorier: {n['calories_kcal']} kcal")
    print(f"  Protein: {n['protein_g']}g")
    print(f"  Fett: {n['total_fat_g']}g")
    print(f"  Kolhydrater: {n['total_carbs_g']}g")

JavaScript: Ladda JSON

// Node.js
const fs = require('fs');

function loadMacroTable(filepath) {
  const raw = fs.readFileSync(filepath, 'utf-8');
  const data = JSON.parse(raw);
  console.log(`Loaded ${data.record_count} foods (version ${data.version})`);
  return data.foods;
}

const foods = loadMacroTable('macro_reference_table.json');

// Gruppera livsmedel efter kategori
const byCategory = {};
for (const food of foods) {
  if (!byCategory[food.category]) {
    byCategory[food.category] = [];
  }
  byCategory[food.category].push(food);
}

// Skriv sammanfattning
for (const [category, items] of Object.entries(byCategory)) {
  console.log(`${category}: ${items.length} foods`);
}

// Hitta låga kalorier, högfiber livsmedel
const highFiber = foods
  .filter(f => f.nutrients.fiber_g >= 5 && f.nutrients.calories_kcal <= 200)
  .sort((a, b) => b.nutrients.fiber_g - a.nutrients.fiber_g);

console.log('\nHigh-fiber, low-calorie foods:');
highFiber.slice(0, 10).forEach(f => {
  console.log(`  ${f.food_name}: ${f.nutrients.fiber_g}g fiber, ${f.nutrients.calories_kcal} kcal`);
});

JavaScript: Ladda CSV i webbläsaren

// Webbläsarbaserad CSV-parsing (inga beroenden)
async function loadMacroCSV(url) {
  const response = await fetch(url);
  const text = await response.text();
  const lines = text.split('\n').filter(line => line.trim());
  const headers = parseCSVLine(lines[0]);

  return lines.slice(1).map(line => {
    const values = parseCSVLine(line);
    const obj = {};
    headers.forEach((header, i) => {
      obj[header] = isNaN(values[i]) ? values[i] : parseFloat(values[i]);
    });
    return obj;
  });
}

function parseCSVLine(line) {
  const result = [];
  let current = '';
  let inQuotes = false;
  for (const char of line) {
    if (char === '"') { inQuotes = !inQuotes; }
    else if (char === ',' && !inQuotes) { result.push(current.trim()); current = ''; }
    else { current += char; }
  }
  result.push(current.trim());
  return result;
}

// Användning
const foods = await loadMacroCSV('/data/macro_reference_table.csv');
console.log(`Loaded ${foods.length} foods`);

Dessa exempel visar de vanligaste operationerna: ladda datan, söka och filtrera, gruppera efter kategori och sortera efter näringstäthet. Datastrukturerna är avsiktligt enkla så att du inte behöver några speciella bibliotek för att arbeta med dem.

Datakällor

Makroreferenstabellerna är sammanställda från följande primära källor:

USDA SR Legacy-databas. USDA Standard Reference Legacy-databasen är den grundläggande datasetet för amerikansk livsmedelskomposition. Den innehåller laboratorieanalyserad näringsdata för över 7 600 livsmedelsartiklar. Våra tabeller använder SR Legacy som primär källa för generiska/obrandade livsmedel. Vi valde SR Legacy framför den nyare FoodData Central FNDDS eftersom SR Legacy-värden är mer allmänt validerade och citerade i näringsforskning.

USDA FoodData Central. För livsmedel som inte täcks av SR Legacy, särskilt nyare livsmedelsartiklar och uppdaterade värden, refererar vi till FoodData Centrals Foundation Foods och Survey Foods dataset.

Internationella livsmedelskompositionsdatabaser. För livsmedel som konsumeras globalt men som kanske inte förekommer i amerikanska databaser, korsrefererar vi data från Public Health Englands McCance och Widdowson kompositionstabeller, Food Standards Australia New Zealand (FSANZ) NUTTAB, den kanadensiska näringsfilen (CNF) och den danska livsmedelskompositionsdatabasen (Frida). Detta är särskilt relevant för tropiska frukter, regionala korn och tillagningsmetoder som är vanliga utanför USA.

Tillverkarens data. För bearbetade och varumärkesartiklar i snacks- och dryckeskategorierna refererar vi till näringsdeklarationer som tillhandahålls av tillverkarna. Där tillverkarens data strider mot laboratorieanalys noterar vi avvikelsen och utgår från laboratorievärdena.

Alla värden har korsrefererats mot minst två oberoende källor. Där källor är oense med mer än 10% har vi undersökt orsaken (vanligtvis olika tillagningsmetoder eller skillnader i sorter) och valt det värde som är mest representativt för hur livsmedlet vanligtvis konsumeras.

Datasetet är versionshanterat. Den aktuella versionen är 1.4.0, senast uppdaterad mars 2026. Vi uppdaterar tabellerna ungefär varje kvartal för att inkludera korrigeringar, lägga till begärda livsmedel och återspegla eventuella betydande förändringar i källdatabaser.

Hur man Bidrar med Korrigeringar

Näringsdata är inneboende ofullkomlig. Livsmedelskomposition varierar beroende på region, säsong, sort och tillagningsmetod. Om du hittar ett fel eller har en korrigering som stöds av en pålitlig källa, vill vi höra om det.

Det finns tre sätt att skicka in korrigeringar:

GitHub Issues. Makroreferenstabellerna är värd i ett offentligt GitHub-repo. Öppna ett ärende med livsmedelsnamnet, det fält du anser vara felaktigt, det nuvarande värdet, det värde du anser vara korrekt och en länk till din källa. Vi granskar ärenden varje vecka.

E-post. Skicka korrigeringar till data@nutrola.com med samma information: livsmedelsnamn, fält, nuvarande värde, föreslaget värde och källa. Vi kommer att svara inom fem arbetsdagar.

Pull requests. Om du är bekväm med Git kan du forka repot, redigera CSV- eller JSON-filen direkt och skicka en pull request. Inkludera din källa i PR-beskrivningen. Vi kommer att granska och slå samman korrigeringar som stöds av pålitlig data.

Vi accepterar inte inlämningar för varumärkes- eller proprietära produkter genom denna process. Dessa hanteras genom Nutrolas huvudlivsmedelsdatabas pipeline, som har sin egen verifieringsarbetsflöde.

Integration med Nutrolas API för Realtidsdata

De nedladdningsbara makroreferenstabellerna är en statisk ögonblicksbild — utmärkta för offline-användning, inbäddade applikationer, utbildningsmaterial och snabba uppslagningar. Men om du behöver realtids näringsdata i stor skala, erbjuder Nutrolas Nutrition Data API allt som finns i dessa tabeller och mycket mer.

API:et täcker över 3 miljoner livsmedelsartiklar (jämfört med 500+ i referenstabellerna), inkluderar fullständiga mikronäringsprofiler med 70+ näringsämnen per artikel, stödjer streckkodsscanning, textsökning och autocomplet, och tillhandahåller data för varumärkesprodukter från 47 länder. Det är samma data som driver Nutrola-appen som används av över 2 miljoner människor dagligen.

För utvecklare: API:et är RESTful, returnerar JSON och erbjuder en gratis nivå med 500 förfrågningar per dag — tillräckligt för prototyper och personliga projekt. Betalda nivåer skalar upp till miljontals förfrågningar. Du kan hitta den fullständiga dokumentationen på api.nutrola.com/docs.

För forskare och institutioner: vi erbjuder akademiska licenser med högre hastighetsgränser och möjligheter för massexport. Kontakta research@nutrola.com för detaljer.

Makroreferenstabellerna och API:et kompletterar varandra. Använd tabellerna för offline-arbete, inbäddade dataset och situationer där du behöver en självständig fil. Använd API:et när du behöver bredd, djup, realtidsuppdateringar och sökfunktionalitet.

Vanliga Frågor

Hur ofta uppdateras makroreferenstabellerna?

Vi uppdaterar tabellerna ungefär varje kvartal. Varje release får ett nytt versionsnummer (den aktuella versionen är 1.4.0). Uppdateringar inkluderar korrigeringar som skickas in av användare, tillägg av vanligt begärda livsmedel och justeringar när våra källdatabaser publicerar reviderade värden. JSON-filen inkluderar versionen och genereringsdatumet i sin metadata, så att du programatiskt kan kontrollera om du har den senaste versionen.

Kan jag använda dessa data i min kommersiella applikation?

Ja. Makroreferenstabellerna släpps under en Creative Commons Attribution 4.0 (CC BY 4.0) licens. Du kan använda, modifiera och återdistribuera datan i både personliga och kommersiella projekt så länge du ger erkännande. En länk till nutrola.com eller en nämning av "Nutrola Macro Reference Tables" i dina datakrediter är tillräckligt. Du behöver inte begära tillstånd eller betala en avgift.

Varför bara 500+ livsmedel och inte hela Nutrola-databasen?

Referenstabellerna är utformade för att vara en praktisk, högkvalitativ delmängd av de mest konsumerade livsmedlen. Att täcka 500+ artiklar över sju kategorier adresserar ungefär 90% av vad folk äter dagligen i de flesta länder. Att expandera till 3 miljoner poster skulle göra filerna otympliga för många användningsfall (den fullständiga databasen överstiger 2 GB). Om du behöver hela datasetet, erbjuder Nutrola API tillgång till allt.

Är värdena per portion eller per 100 gram?

Per portion. Varje post inkluderar en portionsbeskrivning (t.ex. "1 medelstort äpple (182g)") och motsvarande gramvikt, så att du enkelt kan konvertera till per-100g-värden genom att dela varje näringsvärde med portionsvikten och multiplicera med 100. Vi valde värden per portion eftersom de är mer omedelbart användbara för måltidsspårning, måltidsplanering och klientinriktade applikationer.

Hur konverterar jag datan till per-100g-värden?

Multiplicera varje näringsvärde med 100 och dela med fältet serving_weight_g. Till exempel, om en portion kycklingbröst på 170g innehåller 53.4g protein, är värdet per 100g protein (53.4 * 100) / 170 = 31.4g. Här är en snabb Python-funktion:

def per_100g(food, nutrient_field):
    """Konvertera ett näringsvärde per portion till per-100g."""
    serving_weight = food['serving_weight_g']
    if serving_weight == 0:
        return 0
    return round(food[nutrient_field] * 100 / serving_weight, 1)

Vad ska jag göra om ett livsmedel jag behöver inte finns i tabellen?

Först, kontrollera om ett liknande livsmedel finns under ett annat namn — använd din textredigeringsprograms sökfunktion eller ett enkelt skript för att söka i food_name-fältet. Om livsmedlet verkligen inte ingår har du två alternativ: skicka in en begäran via vårt GitHub-repo (vi prioriterar tillägg baserat på efterfrågan), eller använd Nutrolas API som täcker över 3 miljoner livsmedel och är mycket mer sannolikt att ha vad du behöver. För engångsupplockningar låter Nutrola-appen dig söka i hela databasen gratis.