Gratis Makro Reference Tabeller: Download Fuld Ernæringsdata i CSV og JSON

Uanset om du bygger en ernæringsapp, driver et forskningsstudie, coacher kunder, eller blot ønsker et pålideligt referenceark på dit skrivebord, har du brug for rene makrodata i et format, du faktisk kan arbejde med. Offentlige databaser findes, men de er ofte omfattende, inkonsekvente og formateret til bureaukrater snarere end til udviklere.

Vi har samlet et sæt gratis makro reference tabeller, der dækker over 500 almindelige fødevarer med fulde makronæringsstofopdelinger. Dataene er tilgængelige i både CSV og JSON formater, klar til at blive indsat i et regneark, en database, et script eller en applikation. Hver post er blevet verificeret mod primære kilder, og filerne er struktureret, så du kan begynde at bruge dem med det samme uden behov for oprydning eller transformation.

Denne side dækker præcist, hvad der er i tabellerne, hvordan dataene er struktureret, hvordan du kan indlæse dem programmatisk, og hvordan du kan bidrage med rettelser, hvis du finder noget, der skal opdateres.

Hvad Er Inkluderet

Makro reference tabellerne indeholder 500+ af de mest almindeligt forbrugte fødevarer fordelt på syv hovedkategorier. For hver fødevare får du:

• Fødevare navn — det standard engelske navn, der anvendes i ernæringsvidenskab
• Kategori — en af syv overordnede kategorier (mere om disse nedenfor)
• Underkategori — en mere specifik gruppering inden for hovedkategorien
• Beskrivelse af portionsstørrelse — en menneskelig læsbar portionsstørrelse (f.eks. "1 mellemstor banan", "1 kop kogt")
• Portionsvægt i gram — den gram ækvivalent af den portionsstørrelse
• Kalorier — total energi i kilokalorier (kcal)
• Protein — gram protein pr. portion
• Total fedt — gram total fedt pr. portion
• Mættet fedt — gram mættet fedt pr. portion
• Total kulhydrater — gram total kulhydrater pr. portion
• Kostfiber — gram kostfiber pr. portion
• Sukker — gram total sukker pr. portion
• Natrium — milligram natrium pr. portion

Hver værdi rapporteres pr. den angivne portionsstørrelse, ikke pr. 100 gram. Vi valgte denne tilgang, fordi portionsbaserede data er det, de fleste mennesker faktisk har brug for, når de tracker måltider, laver måltidsplaner eller viser ernæringsinformation i en grænseflade. Hvis du har brug for værdier pr. 100 g, er det enkelt at dividere med portionsvægten og multiplicere med 100.

Tabellerne inkluderer ikke mikronæringsstoffer udover natrium og fiber. For fulde mikronæringsstofprofiler (vitaminer, mineraler, aminosyrer) se sektionen om Nutrola's API i slutningen af denne artikel — det er her, de detaljerede data findes.

Dataformat Specifikationer

CSV Format

CSV-filen bruger UTF-8 kodning med en header række. Felter er kommaseparerede, og tekstfelter er indkapslet i citationstegn. Her er, hvordan strukturen ser ud:

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
"Chicken Breast, boneless skinless, cooked","Proteins","Poultry","1 breast (170g)",170,284,53.4,6.2,1.7,0.0,0.0,0.0,126
"Atlantic Salmon, cooked","Proteins","Fish & Seafood","1 fillet (154g)",154,280,39.3,12.4,2.5,0.0,0.0,0.0,109
"Brown Rice, cooked","Grains & Starches","Whole Grains","1 cup (195g)",195,216,5.0,1.8,0.4,44.8,3.5,0.7,10
"Banana, raw","Fruits","Tropical Fruits","1 medium (118g)",118,105,1.3,0.4,0.1,27.0,3.1,14.4,1

CSV-filen er kompatibel med Microsoft Excel, Google Sheets, LibreOffice Calc, Apple Numbers og ethvert programmeringssprog med CSV-parsing support. Ingen speciel konfiguration er nødvendig — åbn filen, og den vil blive parseret korrekt.

JSON Format

JSON-filen indeholder et array af objekter, ét pr. fødevare. Strukturen spejler CSV-felterne:

{
  "version": "1.4.0",
  "generated": "2026-03-12",
  "source": "Nutrola Macro Reference Tables",
  "record_count": 527,
  "foods": [
    {
      "food_name": "Chicken Breast, boneless skinless, cooked",
      "category": "Proteins",
      "subcategory": "Poultry",
      "serving_description": "1 breast (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 inkluderer metadatafelter på topniveau: en versionsstreng til at spore opdateringer, genereringsdato, kilde navn og det samlede antal poster. Dette gør det nemt at verificere, at du har den nyeste version, og at bygge opdateringskontrol-logik ind i dine applikationer.

Numeriske værdier gemmes som tal, ikke strenge. Null-værdier vises ikke — hvis en næringsværdi er ukendt, udelades fødevaren fra datasættet i stedet for at blive inkluderet med manglende data. Dette var et bevidst valg for at holde dataene rene og undgå stille fejl i beregninger.

Feltbeskrivelser

Her er en detaljeret opdeling af hvert felt, inklusive enheder, forventede intervaller og kanttilfælde:

Felt	Type	Enhed	Beskrivelse
food_name	string	—	Standard engelsk navn. Inkluderer tilberedningsmetode hvor relevant (f.eks. "kogt", "rå", "tørret").
category	string	—	En af syv overordnede kategorier. Se kategorisektionen nedenfor.
subcategory	string	—	En mere specifik gruppering. For eksempel, inden for "Proteins" finder du "Poultry", "Red Meat", "Fish & Seafood", "Legumes", og "Eggs".
serving_description	string	—	En menneskelig læsbar portionsstørrelse. Inkluderer altid gramvægten i parentes.
serving_weight_g	number	gram	Den numeriske gramvægt af portionen. Heltalsværdier for de fleste varer, en decimal for varer, hvor præcision er vigtig.
calories_kcal	number	kcal	Total energi. Beregnet ved hjælp af Atwater-systemet (4 kcal/g protein, 4 kcal/g kulhydrater, 9 kcal/g fedt).
protein_g	number	gram	Total protein. Præcision til en decimal.
total_fat_g	number	gram	Total fedt inklusive mættet, monoumættet og flerumættet.
saturated_fat_g	number	gram	Mættede fedtsyrer kun.
total_carbs_g	number	gram	Total kulhydrater inklusive fiber og sukker.
fiber_g	number	gram	Total kostfiber (opløselig + uopløselig).
sugar_g	number	gram	Total sukker (naturligt forekommende + tilsat). Datasættet adskiller ikke tilsat sukker fra naturligt sukker.
sodium_mg	number	milligram	Natriumindhold. Bemærk, at dette er milligram, ikke gram, i modsætning til de andre næringsfelter.

Et par bemærkninger om præcision: alle næringsværdier er afrundet til en decimal. Dette matcher præcisionsniveauet af de underliggende kildedata. At rapportere flere decimaler ville antyde et falsk niveau af nøjagtighed — fødevarers sammensætning varierer naturligt med 5-15% afhængigt af vækstbetingelser, dyrearter og tilberedningsmetoder.

Fødevarekategorier

De 500+ fødevarer er organiseret i syv overordnede kategorier, hver med flere underkategorier:

Proteiner

Cirka 95 poster dækker fjerkræ (kyllingebryst, lår, kalkun, hakket kalkun), rødt kød (oksefilet, hakket oksekød i forskellige magre procent, svinekotelet, lam), fisk og skaldyr (laks, tun, rejer, torsk, tilapia, sardiner), æg (hele, hvide, røræg) og plantebaserede proteiner (tofu, tempeh, seitan, edamame). Bælgfrugter som linser, kikærter og sorte bønner er inkluderet her i stedet for i korn, fordi deres primære ernæringsmæssige rolle er at levere protein.

Korn og Stivelse

Cirka 80 poster dækker fuldkorn (brune ris, havre, quinoa, byg, bulgur), raffinerede korn (hvide ris, hvidt brød, pasta), stivelsesholdige grøntsager (kartofler, søde kartofler, majs) og almindelige kornprodukter (tortillas, bagels, kiks, couscous). Både kogte og tørre værdier er angivet for korn, hvor forskellen er vigtig.

Frugter

Cirka 65 poster dækker almindelige friske frugter (æbler, bananer, appelsiner, jordbær, blåbær, druer), tropiske frugter (mangoer, ananas, papaya, kiwi), tørrede frugter (rosiner, dadler, tørrede abrikoser, tranebær) og frosne frugter. Alle friske frugtposter er for den rå, spiselige del — frø, skræl og kerner er udelukket fra portionsvægten, hvor det er relevant.

Grøntsager

Cirka 85 poster dækker bladgrøntsager (spinat, grønkål, romaine, rucola), korsblomstrede grøntsager (broccoli, blomkål, rosenkål, kål), rodgrøntsager (gulerødder, rødbeder, pastinak, radiser), løg (løg, hvidløg), natskyggefamilien (tomater, peberfrugter, aubergine) og andre almindelige grøntsager (agurk, selleri, zucchini, svampe, asparges). Både rå og kogte værdier er angivet for grøntsager, hvor tilberedning signifikant ændrer næringstætheden pr. portion.

Mejeri og Alternativer

Cirka 70 poster dækker mælk (hel, 2%, skummet og plantebaserede mælkeprodukter), yoghurt (græsk, almindelig, smagssat, plantebaseret), ost (cheddar, mozzarella, feta, hytteost, flødeost, parmesan), smør, fløde og almindelige mejerialternativer (mandelmælk, havremælk, soyamælk, kokos yoghurt). Plantebaserede mælkeprodukter og yoghurter er grupperet her i stedet for i en separat kategori, fordi brugerne typisk vælger dem som direkte substitutter.

Snacks og Forarbejdede Fødevarer

Cirka 75 poster dækker nødder og frø (mandler, valnødder, jordnødder, chiafrø, hørfrø, solsikkefrø), nøddebutter (jordnøddesmør, mandelsmør), almindelige snacks (pretzels, popcorn, granola barer, proteinbarer, trail mix, chips, mørk chokolade), spreads og condiments (hummus, guacamole, salsa, mayonnaise, olivenolie, honning) og andre ofte registrerede genstande som proteinpulver og energibider.

Drikkevarer

Cirka 60 poster dækker juicer (appelsinjuice, æblejuice, tranebærjuice), sodavand (cola, citron-lime sodavand, ingefærøl), sports- og energidrikke, kaffedrikke (sort kaffe, latte, cappuccino, mocha med forskellige mælketyper), smoothie-baser, alkoholiske drikkevarer (øl, vin, spiritus) og almindelige tilsætninger (fløde, sukker, smagsstoffer). Vand er ikke inkluderet, da det ikke har noget makronæringsindhold.

Brug af Data Programmatisk

Hele pointen med at tilbyde CSV og JSON formater er, at du kan indlæse disse data direkte i din kode. Her er fungerende eksempler i Python og JavaScript.

Python: Indlæsning af 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:
            # Konverter numeriske felter fra strenge
            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')

# Find alle fødevarer i en kategori
proteins = [f for f in foods if f['category'] == 'Proteins']
print(f"Fundet {len(proteins)} proteinkilder")

# Find de fødevarer med højeste protein pr. kalorie
foods_sorted = sorted(foods, key=lambda f: f['protein_g'] / max(f['calories_kcal'], 1), reverse=True)
print("\nTop 10 fødevarer efter proteintæthed (g protein pr. 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: Indlæsning af JSON

import json

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

foods = load_macro_json('macro_reference_table.json')

# Byg et opslagordbog efter fødevare navn
lookup = {f['food_name'].lower(): f for f in foods}

# Hurtig opslag
chicken = lookup.get('chicken breast, boneless skinless, cooked')
if chicken:
    n = chicken['nutrients']
    print(f"Kyllingebryst pr. portion ({chicken['serving_description']}):")
    print(f"  Kalorier: {n['calories_kcal']} kcal")
    print(f"  Protein: {n['protein_g']}g")
    print(f"  Fedt: {n['total_fat_g']}g")
    print(f"  Kulhydrater: {n['total_carbs_g']}g")

JavaScript: Indlæsning af JSON

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

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

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

// Gruppér fødevarer efter kategori
const byCategory = {};
for (const food of foods) {
  if (!byCategory[food.category]) {
    byCategory[food.category] = [];
  }
  byCategory[food.category].push(food);
}

// Print oversigt
for (const [category, items] of Object.entries(byCategory)) {
  console.log(`${category}: ${items.length} fødevarer`);
}

// Find lavkalorie, højfiber fødevarer
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('\nHøjfiber, lavkalorie fødevarer:');
highFiber.slice(0, 10).forEach(f => {
  console.log(`  ${f.food_name}: ${f.nutrients.fiber_g}g fiber, ${f.nutrients.calories_kcal} kcal`);
});

JavaScript: Indlæsning af CSV i Browseren

// Browser-baseret CSV parsing (ingen afhængigheder)
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;
}

// Brug
const foods = await loadMacroCSV('/data/macro_reference_table.csv');
console.log(`Indlæst ${foods.length} fødevarer`);

Disse eksempler demonstrerer de mest almindelige operationer: indlæsning af data, søgning og filtrering, gruppering efter kategori og sortering efter næringstæthet. Datastrukturerne er bevidst enkle, så du ikke behøver nogen specielle biblioteker for at arbejde med dem.

Datakilder

Makro reference tabellerne er samlet fra følgende primære kilder:

USDA SR Legacy Database. USDA Standard Reference Legacy-databasen er det grundlæggende datasæt for amerikansk fødevarers sammensætning. Det indeholder laboratorieanalyserede næringsdata for over 7.600 fødevarer. Vores tabeller bruger SR Legacy som den primære kilde til generiske/ubranded fødevarer. Vi valgte SR Legacy frem for den nyere FoodData Central FNDDS, fordi SR Legacy-værdier er mere bredt validerede og citerede i ernæringsforskning.

USDA FoodData Central. For fødevarer, der ikke er dækket af SR Legacy, især nyere fødevarer og opdaterede værdier, henviser vi til FoodData Centrals Foundation Foods og Survey Foods datasæt.

Internationale fødevarekompositionsdatabaser. For fødevarer, der forbruges globalt, men som måske ikke optræder i amerikanske databaser, krydsrefererer vi data fra Public Health Englands McCance og Widdowson sammensætningstabeller, Food Standards Australia New Zealand (FSANZ) NUTTAB, den canadiske næringsfil (CNF) og den danske fødevarekompositionsdatabase (Frida). Dette er særligt relevant for tropiske frugter, regionale korn og tilberedningsmetoder, der er almindelige uden for USA.

Producentdata. For forarbejdede og mærkede varer i snacks og drikkevarer kategorierne henviser vi til næringsfakta paneler leveret af producenterne. Hvor producentdata strider mod laboratorieanalyse, bemærker vi uoverensstemmelsen og default til laboratorieværdierne.

Alle værdier er blevet krydsrefereret mod mindst to uafhængige kilder. Hvor kilder er uenige med mere end 10%, har vi undersøgt årsagen (normalt forskellige tilberedningsmetoder eller forskelle i sorter) og valgt den værdi, der er mest repræsentativ for, hvordan fødevaren typisk forbruges.

Datasættet er versionsstyret. Den nuværende version er 1.4.0, sidst opdateret marts 2026. Vi opdaterer tabellerne cirka hver kvartal for at inkorporere rettelser, tilføje ønskede fødevarer og afspejle eventuelle betydelige ændringer i kilde databaserne.

Sådan Bidrager Du med Rettelser

Ernæringsdata er iboende ufuldkomne. Fødevarers sammensætning varierer efter region, sæson, sort og tilberedningsmetode. Hvis du finder en fejl eller har en rettelse, der er understøttet af en pålidelig kilde, vil vi gerne høre fra dig.

Der er tre måder at indsende rettelser på:

GitHub Issues. Makro reference tabellerne er hostet i et offentligt GitHub-repository. Åbn et issue med fødevare navnet, det felt, du mener er forkert, den nuværende værdi, den værdi, du mener er korrekt, og et link til din kilde. Vi gennemgår issues ugentligt.

Email. Send rettelser til data@nutrola.com med de samme oplysninger: fødevare navn, felt, nuværende værdi, foreslået værdi og kilde. Vi svarer inden for fem arbejdsdage.

Pull requests. Hvis du er fortrolig med Git, kan du forgrene repositoryet, redigere CSV- eller JSON-filen direkte og indsende en pull request. Inkluder din kilde i PR-beskrivelsen. Vi vil gennemgå og fusionere rettelser, der understøttes af pålidelige data.

Vi accepterer ikke indsendelser for mærkede eller proprietære produkter gennem denne proces. Disse håndteres gennem Nutrola's hovedfødevaredatabase pipeline, som har sin egen verifikationsarbejdsgang.

Integration med Nutrola's API for Real-Time Data

De downloadbare makro reference tabeller er et statisk snapshot — fantastisk til offline brug, indlejrede applikationer, uddannelsesmaterialer og hurtige opslag. Men hvis du har brug for realtids ernæringsdata i stor skala, tilbyder Nutrola's Nutrition Data API alt i disse tabeller og meget mere.

API'et dækker over 3 millioner fødevareposter (sammenlignet med 500+ i reference tabellerne), inkluderer fulde mikronæringsstofprofiler med 70+ næringsstoffer pr. post, understøtter stregkodescanning, tekstsøgning og autocomplet, og leverer data for mærkede produkter fra 47 lande. Det er de samme data, der driver Nutrola appen, som bruges af over 2 millioner mennesker dagligt.

For udviklere: API'et er RESTful, returnerer JSON og tilbyder en gratis tier med 500 anmodninger pr. dag — nok til prototyping og personlige projekter. Betalte niveauer skalerer til millioner af anmodninger. Du kan finde den fulde dokumentation på api.nutrola.com/docs.

For forskere og institutioner: vi tilbyder akademiske licenser med forhøjede hastighedsgrænser og bulk eksportmuligheder. Kontakt research@nutrola.com for detaljer.

Makro reference tabellerne og API'et supplerer hinanden. Brug tabellerne til offline arbejde, indlejrede datasæt og situationer, hvor du har brug for en selvstændig fil. Brug API'et, når du har brug for bredde, dybde, realtidsopdateringer og søgefunktionalitet.

Ofte Stillede Spørgsmål

Hvor ofte opdateres makro reference tabellerne?

Vi opdaterer tabellerne cirka hver kvartal. Hver udgivelse får et nyt versionsnummer (den nuværende version er 1.4.0). Opdateringer inkluderer rettelser indsendt af brugere, tilføjelser af ofte ønskede fødevarer og justeringer, når vores kilde databaser offentliggør reviderede værdier. JSON-filen inkluderer versionen og genereringsdatoen i sin metadata, så du programmatisk kan tjekke, om du har den nyeste version.

Kan jeg bruge disse data i min kommercielle applikation?

Ja. Makro reference tabellerne er udgivet under en Creative Commons Attribution 4.0 (CC BY 4.0) licens. Du kan bruge, ændre og redistribuere dataene i både personlige og kommercielle projekter, så længe du giver attribution. Et link til nutrola.com eller en omtale af "Nutrola Macro Reference Tables" i dine datakreditter er tilstrækkeligt. Du behøver ikke at anmode om tilladelse eller betale et gebyr.

Hvorfor kun 500+ fødevarer og ikke hele Nutrola databasen?

Reference tabellerne er designet til at være et praktisk, høj-kvalitets subset af de mest almindeligt forbrugte fødevarer. Dækning af 500+ varer på tværs af syv kategorier adresserer cirka 90% af, hvad folk spiser dagligt i de fleste lande. Udvidelse til 3 millioner poster ville gøre filerne uhåndterlige for mange anvendelser (det fulde datasæt overstiger 2 GB). Hvis du har brug for det fulde datasæt, giver Nutrola API adgang til alt.

Er værdierne pr. portion eller pr. 100 gram?

Pr. portion. Hver post inkluderer en portionsbeskrivelse (f.eks. "1 mellemstor æble (182g)") og den tilsvarende gramvægt, så du nemt kan konvertere til værdier pr. 100 g ved at dividere hver næringsværdi med portionsvægten og multiplicere med 100. Vi valgte værdier pr. portion, fordi de er mere umiddelbart nyttige til måltidssporing, måltidsplanlægning og klientfokuserede applikationer.

Hvordan konverterer jeg dataene til værdier pr. 100 gram?

Multiplicer hver næringsværdi med 100 og divider med feltet serving_weight_g. For eksempel, hvis en kyllingebrystportion på 170 g indeholder 53,4 g protein, er værdien pr. 100 g protein (53,4 * 100) / 170 = 31,4 g. Her er en hurtig Python-funktion:

def per_100g(food, nutrient_field):
    """Konverter en næringsværdi pr. portion til pr. 100 g."""
    serving_weight = food['serving_weight_g']
    if serving_weight == 0:
        return 0
    return round(food[nutrient_field] * 100 / serving_weight, 1)

Hvad skal jeg gøre, hvis en fødevare, jeg har brug for, ikke er i tabellen?

Først, tjek om en lignende fødevare findes under et andet navn — brug din tekstredigers søgefunktion eller et simpelt script til at søge i food_name feltet. Hvis fødevaren virkelig ikke er inkluderet, har du to muligheder: indsende en anmodning gennem vores GitHub repository (vi prioriterer tilføjelser baseret på efterspørgsel), eller bruge Nutrola's API, som dækker over 3 millioner fødevarer og er langt mere tilbøjelig til at have det, du har brug for. For engangsopslag giver Nutrola appen dig mulighed for at søge i det fulde datasæt gratis.