---
title: "Create or Update Product"
method: PATCH
path: "/api/v3/product/{code}"
tags: ["Products"]
---

# Create or Update Product

`PATCH /api/v3/product/{code}`

## Request

- Base URL: `https://world.openfoodfacts.org`
- URL: `https://world.openfoodfacts.org/api/v3/product/{code}`
- Auth: API key in cookie `session` and API key in header `User-Agent`

This API allows to create or update a product (if the product already exists, its data is updated, otherwise it is created), or to analyze a test product (in which case no product is created or updated). To analyze a product, the "code" path component needs to contain the value "test" instead of a barcode.

New API to send structured product data in a JSON format instead of in a flattened list of key / value pairs field as-in the current product add / edit API that relies on a multipart/form-data format.

Important: this new Product WRITE API has been deployed in production, but it is still under development, and it may change.

This new API is used in particular to send structured packaging data: https://openfoodfacts.github.io/openfoodfacts-server/dev/explain-packaging-data/

The new API is gradually being extended to support other product fields.

Currently supported fields are:
  - language specific fields (e.g. product name, ingredients text)
  - tags fields (e.g. categories, labels)
  - packaging fields (e.g. packagings, packagings_add, packagings_complete)
  - image selection of uploaded images (e.g. front, ingredients, nutrition, packaging) for specific languages

## Path parameters

- `code` string, required

## Request body

- object
  - `lc` string: 2 letter code of the language of the interface. Used for localizing some fields in returned values (e.g. knowledge panels). If not passed, the language may be inferred by the country of the user (passed through the cc field or inferred by the IP address). Full list at https://static.openfoodfacts.org/data/taxonomies/languages.json
  - `cc` string: 2 letter code of the country of the user. Used for localizing some fields in returned values (e.g. knowledge panels). If not passed, the country may be inferred by the IP address of the request. Full list at https://static.openfoodfacts.org/data/taxonomies/countries.json
  - `fields` string: Comma separated list of fields requested in the response. Special values: "updated": returns field that were updated by the query (e.g. sending "packagings" or "packagings_add" would return "packagings"), "none": returns no fields, "all": returns all fields except generated fields that need to be explicitly requested such as "knowledge_panels". Defaults to "updated" for WRITE requests, and "all" for READ requests.
  - `tags_lc` string: 2 letter language code to request names of tags in a specific language. For READ requets: if passed, all taxonomized tags of the response will include a lc_name property with the translation in the requested language, if available. Otherwise, the property value will contain the name in the original language, prefixed by the 2 language code and a colon. For WRITE requests: if passed, taxonomized tags fields with a lc_name property will be considered to be in this language.
  - `user_id` string
  - `password` string, password: Password for login
  - `product` ProductUpdateApiV3: Products have list of tags of different types (e.g. categories, labels) that can be replaced or added to with the following properties in API v3.
    - `product_type` 'beauty' | 'food' | 'petfood' | 'product': The product type is a fundamental separation that tells on which platform the product is made available: Open Food Facts, Open Beauty Facts, Open Pet Food Facts or Open Products Facts. Each platform has variations on the way it analyses the product. Changing the product type moves the product to the new platform. It must be done thoughtfully.
    - `categories_tags` InputTaxonomyTagEntry[]: An array of categories tag entries that will replace existing categories
    - `categories_tags_add` InputTaxonomyTagEntry[]: An array of categories tag entries that will be added to existing categories
    - `packagings` PackagingComponentWrite[]: The packagings object is an array of individual packaging component objects. The Packaging data document explains how packaging data is structured in Open Food Facts: https://openfoodfacts.github.io/openfoodfacts-server/dev/explain-packaging-data/
      - `number_of_units` integer: Number of units of this packaging component contained in the product (e.g. 6 for a pack of 6 bottles)
      - `shape` union: The shape property is canonicalized using the packaging_shapes taxonomy.
        - object
          - `id` string: Canonical id of the entry in the taxonomy. If the value cannot be mapped to a taxonomy entry, the value must be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
        - object
          - `lc_name` string: Name of the entry in the language specified in the tags_lc field of the request. If the translation is not available, the value must be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
      - `material` union: The material property is canonicalized using the packaging_materials taxonomy.
        - object
          - `id` string: Canonical id of the entry in the taxonomy. If the value cannot be mapped to a taxonomy entry, the value must be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
        - object
          - `lc_name` string: Name of the entry in the language specified in the tags_lc field of the request. If the translation is not available, the value must be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
      - `recycling` union: The recycling property is canonicalized using the packaging_recycling taxonomy.
        - object
          - `id` string: Canonical id of the entry in the taxonomy. If the value cannot be mapped to a taxonomy entry, the value must be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
        - object
          - `lc_name` string: Name of the entry in the language specified in the tags_lc field of the request. If the translation is not available, the value must be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
      - `quantity_per_unit` string: Quantity (weight or volume) of food product contained in the packaging component. (e.g. 75cl for a wine bottle)
      - `weight_specified` union: Weight (as specified by the manufacturer) of one unit of the empty packaging component (in grams). (e.g. for a 6 pack of 1.5l water bottles, it might be 30, the weight in grams of 1 empty water bottle without its cap which is a different packaging component). If passed a string - possibly with an unit - it will be converted to a number.
        - number
        - string
      - `weight_measured` union: Weight (as measured by one or more users) of one unit of the empty packaging component (in grams). (e.g. for a 6 pack of 1.5l water bottles, it might be 30, the weight in grams of 1 empty water bottle without its cap which is a different packaging component). If passed a string - possibly with an unit - it will be converted to a number.
        - number
        - string
      - `brands` string: A comma separated list of brands / product names for the packaging component (e.g. "Tetra Pak", Tetra Brik"
      - `labels` string: A comma separated list of labels, canonicalized with the packaging_labels taxonomy (e.g. "en:FSC, fr:Encre végétale")
    - `packagings_add` PackagingComponentWrite[]: The packagings object is an array of individual packaging component objects. The Packaging data document explains how packaging data is structured in Open Food Facts: https://openfoodfacts.github.io/openfoodfacts-server/dev/explain-packaging-data/
      - `number_of_units` integer: Number of units of this packaging component contained in the product (e.g. 6 for a pack of 6 bottles)
      - `shape` union: The shape property is canonicalized using the packaging_shapes taxonomy.
        - object
          - `id` string: Canonical id of the entry in the taxonomy. If the value cannot be mapped to a taxonomy entry, the value must be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
        - object
          - `lc_name` string: Name of the entry in the language specified in the tags_lc field of the request. If the translation is not available, the value must be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
      - `material` union: The material property is canonicalized using the packaging_materials taxonomy.
        - object
          - `id` string: Canonical id of the entry in the taxonomy. If the value cannot be mapped to a taxonomy entry, the value must be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
        - object
          - `lc_name` string: Name of the entry in the language specified in the tags_lc field of the request. If the translation is not available, the value must be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
      - `recycling` union: The recycling property is canonicalized using the packaging_recycling taxonomy.
        - object
          - `id` string: Canonical id of the entry in the taxonomy. If the value cannot be mapped to a taxonomy entry, the value must be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
        - object
          - `lc_name` string: Name of the entry in the language specified in the tags_lc field of the request. If the translation is not available, the value must be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
      - `quantity_per_unit` string: Quantity (weight or volume) of food product contained in the packaging component. (e.g. 75cl for a wine bottle)
      - `weight_specified` union: Weight (as specified by the manufacturer) of one unit of the empty packaging component (in grams). (e.g. for a 6 pack of 1.5l water bottles, it might be 30, the weight in grams of 1 empty water bottle without its cap which is a different packaging component). If passed a string - possibly with an unit - it will be converted to a number.
        - number
        - string
      - `weight_measured` union: Weight (as measured by one or more users) of one unit of the empty packaging component (in grams). (e.g. for a 6 pack of 1.5l water bottles, it might be 30, the weight in grams of 1 empty water bottle without its cap which is a different packaging component). If passed a string - possibly with an unit - it will be converted to a number.
        - number
        - string
      - `brands` string: A comma separated list of brands / product names for the packaging component (e.g. "Tetra Pak", Tetra Brik"
      - `labels` string: A comma separated list of labels, canonicalized with the packaging_labels taxonomy (e.g. "en:FSC, fr:Encre végétale")
    - `packagings_complete` integer: Indicate if the packagings array contains all the packaging parts of the product. This field can be set by users when they enter or verify packaging data. Possible values are 0 or 1.
    - `lang` string: 2 letter language code of the main language of the product (the most prominent on the packaging)
    - `quantity` string
    - `serving_size` string
    - `images` object
      - `selected` ImagesSelected: Images with specific information (e.g. front, ingredients, nutrition, packaging) for specific languages. Each selected image is a cropped version of an uploaded image.
        - `front` unknown
        - `ingredients` unknown
        - `nutrition` unknown
        - `packaging` unknown

## Response `200`

The response will include a "product" structure. The fields returned in this structure will depend on the value of the "fields" input field:

- "updated" (default): all fields updated by the query will be returned, including fields that are directly generated from the updated fields. For instance, sending "packagings" or "packagings_add" will return the "packagings" field.

- "none": no fields are returned.

- "all": returns all fields except generated fields that need to be explicitly requested such as "knowledge_panels".

The "fields" values can also be concatenated: "all,knowledge_panels"

- object: A response object to describe if a READ or WRITE request was successful or not, and if there were errors or warnings, and what the impact of those errors or warnings was.
  - `status` 'success' | 'success_with_warnings' | 'success_with_errors' | 'failure': Overall status of the request: whether it failed or succeeded, with or without warnings or errors.
  - `result` object: Overall result of the request (e.g. a product has been created)
    - `id` string: Identifier of a response result entry
    - `name` string: Name of the response result entry in English.
    - `lc_name` string: Name of the response result entry in the language specified in tags_lc, if supplied.
  - `warnings` WarningOrError[]: List of warnings. Warnings are used to alert about something that may be wrong, but is not necessarily wrong (e.g. a nutrient value that is unexpectedly high).
    - `message` object
      - `id` string: Identifier of a response message.
      - `name` string: Name of the response message entry in English.
      - `lc_name` string: Name of the response message entry in the language specified in tags_lc, if supplied.
      - `description` string: Description of the problem specific to the request, in English.
      - `lc_description` string: Description of the problem specific to the request, in the language specified in tags_lc, if supplied.
    - `field` object: Field that triggered the warning or error.
      - `id` string: Name of the field that triggered the warning or error.
      - `value` string: Value of the field that triggered the warning or error.
    - `impact` object
      - `id` string
      - `name` string
      - `lc_name` string
      - `description` string
      - `lc_description` string
  - `errors` WarningOrError[]: List of errors. Errors are used to alert about something that is definitely wrong (e.g. a nutrient value that is impossibly high).
    - `message` object
      - `id` string: Identifier of a response message.
      - `name` string: Name of the response message entry in English.
      - `lc_name` string: Name of the response message entry in the language specified in tags_lc, if supplied.
      - `description` string: Description of the problem specific to the request, in English.
      - `lc_description` string: Description of the problem specific to the request, in the language specified in tags_lc, if supplied.
    - `field` object: Field that triggered the warning or error.
      - `id` string: Name of the field that triggered the warning or error.
      - `value` string: Value of the field that triggered the warning or error.
    - `impact` object
      - `id` string
      - `name` string
      - `lc_name` string
      - `description` string
      - `lc_description` string
  - `product` ProductV3: Specific data about a product to enable personal ranking
    - `product_type` 'beauty' | 'food' | 'petfood' | 'product': The product type is a fundamental separation that tells on which platform the product is made available: Open Food Facts, Open Beauty Facts, Open Pet Food Facts or Open Products Facts. Each platform has variations on the way it analyses the product. Changing the product type moves the product to the new platform. It must be done thoughtfully.
    - `product_name` string: The name of the product in the main language of the product (lang field)
    - `abbreviated_product_name` string: Abbreviated product name (e.g. abbreviated product name printed on receipts) in the main language of the product (lang field)
    - `code` string, required: barcode of the product (can be EAN-13 or internal codes for some food stores), for products without a barcode, Open Food Facts assigns a number starting with the 200 reserved prefix
    - `codes_tags` string[]
    - `generic_name` string: Generic / legal name of the product in the main language of the product (lang field)
    - `id` string: internal identifier for the product, usually set to the value of `code`, except on the producers platform where it is prefixed by the owner
    - `lc` string: Main language of the product. This is a duplicate of `lang` property (for historical reasons).
    - `lang` string: Main language of the product. This should be the main language of product packaging (if one is predominant). Main language is also used to decide which ingredients list to parse.
    - `nova_group` integer: Nova group as an integer from 1 to 4. See https://world.openfoodfacts.org/nova
    - `nova_groups` string
    - `obsolete` string
    - `obsolete_since_date` string: A date at which the product was declared obsolete. This means it's not produced any more.
    - `product_quantity` string: The size in g or ml for the whole product. It is a normalized version of the `quantity` field. A `quantity` of "2 x 60 g" leads to `product_quantity`: "120".
    - `product_quantity_unit` string: The unit (either g or ml) for the corresponding `product_quantity`. It is computed from the `quantity` field. A `quantity` of "6 x 250 ml" leads to `product_quantity_unit`: "ml".
    - `quantity` string: The quantity of the product, with the corresponding number of portions or unit (g, ml, kg, l, cl, oz, lbs...). It should be the value as displayed on the product. The ℮ sign is allowed. When it refers to the number of portions, it can be filled without any units (e.g. "6 eggs").
    - `schema_version` integer, required: Version of the product object schema used in the response. This indicates the structure of the 'product' field itself. For more details, please read: https://openfoodfacts.github.io/openfoodfacts-server/api/ref-api-and-product-schema-change-log
    - `additives_n` integer: Number of food additives.
    - `checked` string
    - `complete` integer
    - `completeness` number
    - `ecoscore_grade` string: See also: `ecoscore_tags`
    - `ecoscore_score` integer: See also: `ecoscore_tags`
    - `food_groups` string
    - `food_groups_tags` string[]
    - `nutrient_levels` object: Traffic light indicators on main nutrients levels
      - `fat` 'low' | 'moderate' | 'high'
      - `salt` 'low' | 'moderate' | 'high'
      - `saturated-fat` 'low' | 'moderate' | 'high'
      - `sugars` 'low' | 'moderate' | 'high'
    - `packaging_text` string: Recycling instructions as raw text, e.g. Plastic bottle to recycle, Plastic cap to recycle. This will get automatically parsed and will be used to compute the Eco-Score. You can either request it (if it exists) or send it in a specific language.
    - `packagings` PackagingComponent[]: The packagings object is an array of individual packaging component objects. The Packaging data document explains how packaging data is structured in Open Food Facts: https://openfoodfacts.github.io/openfoodfacts-server/dev/explain-packaging-data/ The shape, material and recycling properties of each packaging component are linked to entries in the packaging_shapes, packaging_materials and packaging_recycling taxonomies: https://world.openfoodfacts.org/data/taxonomies/packaging_shapes.json https://world.openfoodfacts.org/data/taxonomies/packaging_materials.json https://world.openfoodfacts.org/data/taxonomies/packaging_recycling.json If the tags_lc field is set, the properties will include a lc_name field with the translation in the requested language.
      - `number_of_units` integer: umber of units of this packaging component contained in the product (e.g. 6 for a pack of 6 bottles)
      - `shape` Shape: The shape property is canonicalized using the packaging_shapes taxonomy. Taxonomized values are available using the partial taxonomy API, the autosuggest API or the full packaging_shapes taxonomy JSON export.
        - `id` string: Canonical id of the entry in the taxonomy. If the value cannot be mapped to a taxonomy entry, the value will be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
        - `lc_name` string: Name of the entry in the language requested in the tags_lc field of the request. This field is returned only of tags_lc is specified. If the translation is not available, or if the entry does not exist in the taxonomy, the value will be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
      - `material` Material: The material property is canonicalized using the packaging_materials taxonomy. Taxonomized values are available using the partial taxonomy API, the autosuggest API or the full packaging_material taxonomy JSON export.
        - `id` string: Canonical id of the entry in the taxonomy. If the value cannot be mapped to a taxonomy entry, the value will be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
        - `lc_name` string: Name of the entry in the language requested in the tags_lc field of the request. This field is returned only of tags_lc is specified. If the translation is not available, or if the entry does not exist in the taxonomy, the value will be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
      - `recycling` Recycling: The recycling property is canonicalized using the packaging_recycling taxonomy. Taxonomized values are available using the partial taxonomy API, the autosuggest API or the full packaging_recycling taxonomy JSON export.
        - `id` string: Canonical id of the entry in the taxonomy. If the value cannot be mapped to a taxonomy entry, the value will be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
        - `lc_name` string: Name of the entry in the language requested in the tags_lc field of the request. This field is returned only of tags_lc is specified. If the translation is not available, or if the entry does not exist in the taxonomy, the value will be the name of the entry in its original language prefixed by the language 2 letter code and a colon.
      - `quantity_per_unit` string: Quantity (weight or volume) of food product contained in the packaging component. (e.g. 75cl for a wine bottle)
      - `quantity_per_unit_value` number: Value parsed from the quantity field.
      - `quantity_per_unit_unit` string: Unit parsed and normalized from the quantity field.
      - `weight_specified` number: Weight (as specified by the manufacturer) of one unit of the empty packaging component (in grams). (e.g. for a 6 pack of 1.5l water bottles, it might be 30, the weight in grams of 1 empty water bottle without its cap which is a different packaging component).
      - `weight_measured` number: Weight (as measured by one or more users) of one unit of the empty packaging component (in grams). (e.g. for a 6 pack of 1.5l water bottles, it might be 30, the weight in grams of 1 empty water bottle without its cap which is a different packaging component).
      - `weight_estimated` number: Weight (as estimated from similar products) of one unit of the empty packaging component (in grams). (e.g. for a 6 pack of 1.5l water bottles, it might be 30, the weight in grams of 1 empty water bottle without its cap which is a different packaging component).
      - `weight` number: Weight of one unit of the empty packaging component.
      - `weight_source_id` string: Indicates which field was used to populate the "weight" field. Either "specified", "measured", or "estimated"
    - `packagings_complete` integer: Indicate if the packagings array contains all the packaging parts of the product. This field can be set by users when they enter or verify packaging data. Possible values are 0 or 1.
    - `pnns_groups_1` string: Category of food according to [French Nutrition and Health Program](https://fr.wikipedia.org/wiki/Programme_national_nutrition_sant%C3%A9)
    - `pnns_groups_1_tags` string[]
    - `pnns_groups_2` string: Sub Category of food according to [French Nutrition and Health Program](https://fr.wikipedia.org/wiki/Programme_national_nutrition_sant%C3%A9)
    - `pnns_groups_2_tags` string[]
    - `popularity_key` integer: An imprecise measurement of popularity based on Scan statistics. A higher value means higher popularity.
    - `popularity_tags` string[]: Indicators for the popularity of a product, like the amount of scans in a specific year. `popularity_tags` values from previous years are kept, if there is no popularity_tags at all, then it was never popular. This field must be used with care. In countries where Open Food Facts is not widely used, a product may obtain the value "top-90-percent-scans-2021" with a single scan.
    - `scans_n` integer: Number of scans performed with the official Open Food Facts mobile application, the last year for which the product was scanned (current year excluded). This value is computed once a year by scanbot.pl. It is possible that a product has never been scanned at all: `scans_n` is not given in this case. See also `unique_scans_n` field.
    - `unique_scans_n` integer: Number of unique scans performed with the official Open Food Facts mobile application, the last year for which the product was scanned (current year excluded). Unique scans means it is based on different IPs. This value is computed once a year by scanbot.pl. See also `scans_n` field.
    - `serving_quantity` string: Normalized version of serving_size. Note that this is NOT the number of servings by product. <small>(in perl, see `normalize_serving_size`)</small>
    - `serving_quantity_unit` string: The unit (either g or ml) for the correponding serving_quantity.
    - `serving_size` string: Serving size text (generally in g or ml). We expect a quantity + unit but the user is free to input any string.
    - `brands` string: Comma separated list of brands (not taxonomized), in the last language used to edit it (recorded in brands_lc) This field is mostly used for debugging and testing purposes. Do not use it for display purposes.
    - `brands_tags` IndexedTaxonomyTagEntry[]: An array of indexed brands tag entries (for search). That is the id of brands found in taxonomy + brands not found in taxonomy (with case / accents / spaces normalized). This is mostly used for search as the normalization of entries not in the taxonomy is lossy.
    - `categories` string: Comma separated list of categories (not taxonomized), in the last language used to edit it (recorded in categories_lc) This field is mostly used for debugging and testing purposes. Do not use it for display purposes.
    - `categories_tags` IndexedTaxonomyTagEntry[]: An array of indexed categories tag entries (for search). That is the id of categories found in taxonomy + categories not found in taxonomy (with case / accents / spaces normalized). This is mostly used for search as the normalization of entries not in the taxonomy is lossy.
    - `checkers_tags` string[]
    - `cities` string
    - `cities_tags` object[]
    - `correctors_tags` string[]
    - `countries` string: List of countries where the product is sold.
    - `countries_tags` string[]
    - `ecoscore_tags` string[]: All ecoscore of a product. Most of the time it's only one value, but it might eventually be more for products composed of sub-products. See also: `ecoscore_score`, `ecoscore_grade`.
    - `emb_codes` string: Packager code. EMB is the French system of traceability codes for packager.
    - `emb_codes_tags` object[]
    - `labels` string
    - `labels_tags` string[]
    - `entry_dates_tags` string[]: The data as a series of tag: `yyyy-mm-dd`, `yyyy-mm`, `yyyy`
    - `manufacturing_places` string: Places where the product was manufactured or transformed.
    - `manufacturing_places_tags` string[]
    - `nova_groups_tags` string[]
    - `nutrient_levels_tags` string[]
    - `tags_sources` object: All the relevant data on the sources of the different tags of the product. The data is sorted by the sources from which the tags are obtained, e.g. packaging, producer, predicted. The current sources are: - packaging: what is written on the packaging of the product - manufacturer: information that was sent directly from the manufacturer to Open Food Facts, through our producers platform - ingredients: information that is derived from the ingredients list (e.g. allergens and traces) - database-* (e.g. database-usda): information from another open database - label-* (e.g. label-non-gmo-project): information from a label organization (e.g. some labels send us lists of products that have the label) New sources may be added at anytime, so we are using patternProperties to make sure parsing does not break if a new source is encountered.
    - `images` object: Uploaded and selected images of the product.
      - `uploaded` object: List of all images uploaded by users or manufacturers. Those images are typically not displayed to users, but are used in edit mode to crop images with specific information for specific languages. (See images.selected) Older uploaded images that may correspond to older revisions of the product are also kept in this list.
      - `selected` ImagesSelected: List of all images selected by users or manufacturers. Those images are typically displayed to users, and are used in edit mode to crop images with specific information for specific languages. (See images.uploaded)
        - `front` unknown
        - `ingredients` unknown
        - `nutrition` unknown
        - `packaging` unknown
    - `selected_images` object: URLs of selected images, generated at runtime.
    - `last_image_dates_tags` string[]: An array of tags entries to indicated the year, month and day of the last image upload (in formats YYYY, YYYY-MM, YYYY-MM-DD).
    - `last_image_t` integer: timestamp of last image upload
    - `ecoscore_data` object: An object about a lot of details about data needed for Eco-Score computation and complementary data of interest.
      - `adjustments` object
        - `origins_of_ingredients` object
          - `aggregated_origins` object[]: List of aggregated origins of ingredients and their impact.
            - `epi_score` string
            - `origin` string: Country or region of origin for the ingredient.
            - `percent` integer: Percentage of this ingredient from the specified origin.
            - `transportation_score` integer, nullable: Transportation score associated with this ingredient's origin.
          - `epi_score` integer: Environmental Performance Index (EPI) score for the ingredient's origin.
          - `epi_value` integer
          - `origins_from_categories` string[]: List of origins derived from product categories, eg for PDO.
          - `origins_from_origins_field` string[]: List of origins explicitly stated in the product's origins field.
          - `transportation_score` integer
          - `transportation_scores` EcoscoreCountryValues
          - `transportation_value` integer
          - `transportation_values` EcoscoreCountryValues
          - `value` integer
          - `values` EcoscoreCountryValues
          - `warning` string
        - `packaging` object
          - `non_recyclable_and_non_biodegradable_materials` integer
          - `packagings` object[]
            - `ecoscore_material_score` integer
            - `ecoscore_shape_ratio` integer
            - `material` string
            - `shape` string
            - `number_of_units` integer
            - `quantity_per_unit` string: The quantity per packaging unit, as a string.
            - `quantity_per_unit_unit` string
            - `quantity_per_unit_value` number
            - `recycling` string
            - `weight_measured` number
          - `score` integer
          - `value` integer
          - `warning` string
        - `production_system` object
          - `labels` string[]
          - `value` integer
          - `warning` string
        - `threatened_species` object
          - `ingredient` string
          - `value` integer
      - `agribalyse` Agribalyse
        - `agribalyse_proxy_food_code` string
        - `agribalyse_food_code` string
        - `co2_agriculture` number
        - `co2_consumption` integer
        - `co2_distribution` number
        - `co2_packaging` number
        - `co2_processing` number
        - `co2_total` number
        - `co2_transportation` number
        - `code` string
        - `dqr` string
        - `ef_agriculture` number
        - `ef_consumption` integer
        - `ef_distribution` number
        - `ef_packaging` number
        - `ef_processing` number
        - `ef_total` number
        - `ef_transportation` number
        - `is_beverage` integer
        - `name_en` string: This can be returned in many other languages like name_fr (for french).
        - `score` integer
        - `version` string
      - `grade` string
      - `grades` object
      - `missing` object
        - `labels` integer
        - `origins` integer
        - `packagings` integer
      - `missing_data_warning` integer
      - `previous_data` object
        - `grade` string, nullable
        - `score` integer, nullable
        - `agribalyse` Agribalyse
          - `agribalyse_proxy_food_code` string
          - `agribalyse_food_code` string
          - `co2_agriculture` number
          - `co2_consumption` integer
          - `co2_distribution` number
          - `co2_packaging` number
          - `co2_processing` number
          - `co2_total` number
          - `co2_transportation` number
          - `code` string
          - `dqr` string
          - `ef_agriculture` number
          - `ef_consumption` integer
          - `ef_distribution` number
          - `ef_packaging` number
          - `ef_processing` number
          - `ef_total` number
          - `ef_transportation` number
          - `is_beverage` integer
          - `name_en` string: This can be returned in many other languages like name_fr (for french).
          - `score` integer
          - `version` string
      - `score` integer
      - `scores` object
      - `status` string
    - `ecoscore_extended_data_version` string
    - `environment_impact_level` string
    - `environment_impact_level_tags` object[]
    - `additives_tags` string[]
    - `allergens` string: comma separated list of allergens
    - `allergens_lc` string: language in which `allergens` where input
    - `allergens_hierarchy` string[]
    - `allergens_tags` string[]
    - `ingredients` Ingredient[]: This structure gives the different ingredients and some information about them, like estimate on their quantity.
      - `id` string
      - `ingredients` Ingredient[]: This structure gives the different ingredients and some information about them, like estimate on their quantity.
      - `percent` integer: The percentage of the ingredient.
      - `percent_estimate` number: Estimated percentage of the ingredient.
      - `percent_max` union: Maximum percentage of the ingredient.
        - string
        - number
      - `percent_min` integer: Minimum percentage of the ingredient.
      - `text` string: Text description of the ingredient.
      - `vegan` string: Indicates if the ingredient is vegan.
      - `vegetarian` string: Indicates if the ingredient is vegetarian.
    - `ingredients_analysis` object
      - `en:palm-oil` string[]
      - `en:vegan-status-unknown` string[]
      - `en:vegetarian-status-unknown` string[]
    - `ingredients_analysis_tags` string[]
    - `ingredients_from_or_that_may_be_from_palm_oil_n` integer
    - `ingredients_from_palm_oil_n` integer
    - `ingredients_from_palm_oil_tags` object[]
    - `ingredients_hierarchy` string[]
    - `ingredients_n` integer
    - `ingredients_n_tags` string[]
    - `ingredients_original_tags` string[]
    - `ingredients_percent_analysis` integer: Indicates the result of ingredients analysis processing * not present -> we didn't run ingredient percent analysis (e.g. we have no ingredients) * 1: we estimated the ingredients percent. * -1 : we tried to estimate the ingredients, but the values were impossible. (e.g. if the sum of % is above 100%)
    - `ingredients_sweeteners_n` integer: Number of sweeteners additives in the ingredients. Undefined if ingredients are not specified.
    - `ingredients_non_nutritive_sweeteners_n` integer: Number of non-nutritive sweeteners additives (as specified in the Nutri-Score formula) in the ingredients. Undefined if ingredients are not specified.
    - `ingredients_tags` string[]
    - `ingredients_lc` string: Language that was used to parse the ingredient list. If `ingredients_text` is available for the product main language (`lang`), `ingredients_lc=lang`, otherwise we look at `ingredients_text` fields for other languages and set `ingredients_lc` to the first non-empty `ingredient_text`.
    - `ingredients_text` string: Raw list of ingredients. This will get automatically parsed and get used to compute the Eco-Score or find allergens, etc.. It's a copy of ingredients_text in the main language of the product (see `lang` proprety).
    - `ingredients_text_with_allergens` string: Same text as `ingredients_text` but where allergens have HTML elements around them to identify them
    - `ingredients_that_may_be_from_palm_oil_n` integer
    - `ingredients_that_may_be_from_palm_oil_tags` object[]
    - `ingredients_with_specified_percent_n` integer
    - `ingredients_with_specified_percent_sum` integer
    - `ingredients_with_unspecified_percent_n` integer
    - `ingredients_with_unspecified_percent_sum` integer
    - `known_ingredients_n` integer
    - `origins` string: Origins of ingredients
    - `origins_hierarchy` object[]
    - `origins_lc` string
    - `origins_tags` object[]
    - `traces` string: List of substances that might cause allergies that are present in trace amounts in the product (this does not include the ingredients, as they are not only present in trace amounts). It is taxonomized with the allergens taxonomy. Refer to the [allergens taxonomy](https://static.openfoodfacts.org/data/taxonomies/allergens.json)
    - `traces_hierarchy` union[]
      - union
        - object
        - string
    - `traces_lc` string
    - `traces_tags` union[]
      - union
        - object
        - string
    - `unknown_ingredients_n` integer
    - `nutrition` object: Fields related to the nutrition facts of a product Input nutrient sets can be updated directly with API v3. API v2 can still be used to update input sets for the default source (*packaging* on the public platform and *manufacturer* on the pro platform).
      - `aggregated_set` object: A set that combines nutrient data from preferred sources, with normalized units, and for a normalized 100g or 100ml quantity. It takes values from multiple sources (by priority: manufacturer, packaging, usda, estimate) and normalizes all values to the same unit: g for weights, kJ for energy and energy-kj, kcal for energy-kcal. The aggregated_set is read-only, and cannot be modified directly. It is computed from the other nutrient sets available for the product.
        - `preparation` 'as_sold' | 'prepared': Indicates whether the nutrition values refer to the product *as_sold* or *prepared*. The preparation state affects nutrient values.
        - `per` '100g' | '100ml' | 'serving': The nutrition data on the package can be per serving, per 100g or per 100ml. This is essential to understand if values in the `nutrients` object apply for a serving, for 100g or for 100ml.
        - `nutrients` object: All known nutrients for the product. You can get all possible nutrients from the [nutrients taxonomy](https://static.openfoodfacts.org/data/taxonomies/nutrients.json). New nutrients are regularly added. Clients should not break if they encounter an unexpected nutrient to preserve compatibility.
          - `energy` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `energy-kcal` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `energy-kj` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `fat` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `saturated-fat` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `trans-fat` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `cholesterol` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `salt` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `sodium` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `carbohydrates` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `carbohydrates-total` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `fiber` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `sugars` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `added-sugars` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `proteins` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `vitamin-d` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `calcium` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `iron` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
          - `potassium` object: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
            - `source` string: Indicates the original source like “packaging”, “manufacturer”, “estimate”, “usda”
            - `source_per` '100g' | '100ml' | 'serving': Indicates if the original source is per serving or per 100g, 100ml
            - `source_index` integer: Index of the source nutrient set in the input_sets array of the nutrition field
      - `input_sets` object[]: An array of nutrient sets of the product. Each nutrient set represents a version of the nutrition facts, defined by a combination of: - the source of the data (e.g. *packaging*, *manufacturer*, *estimate*). - the preparation state (e.g. *as_sold* or *prepared*), - the reference quantity (*per 100g*, *per 100ml* or *per serving*), and This structure allows capturing multiple nutritional profiles for a single product.
        - `nutrients` object: All known nutrients for the product. You can get all possible nutrients from the [nutrients taxonomy](https://static.openfoodfacts.org/data/taxonomies/nutrients.json). New nutrients are regularly added. Clients should not break if they encounter an unexpected nutrient to preserve compatibility.
          - `energy` NutrientValuesV3WithValueString: It is the same as `energy-kj` if we have it, or computed from `energy-kcal` otherwise (per 100g or per serving) in kj
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `energy-kcal` NutrientValuesV3WithValueString: energy in kcal, if it is specified (per 100g or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `energy-kj` NutrientValuesV3WithValueString: energy in kj, if it is specified (per 100g or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `fat` NutrientValuesV3WithValueString: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `saturated-fat` NutrientValuesV3WithValueString: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `trans-fat` NutrientValuesV3WithValueString: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `cholesterol` NutrientValuesV3WithValueString: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `salt` NutrientValuesV3WithValueString: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `sodium` NutrientValuesV3WithValueString: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `carbohydrates-total` NutrientValuesV3WithValueString: This follows the US / Canada definition of carbohydrates which includes fiber, also known as gross carbohydrates (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `carbohydrates` NutrientValuesV3WithValueString: This is the available carbohydrates (excluding fiber), also known as net carbohydrates (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `fiber` NutrientValuesV3WithValueString: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `sugars` NutrientValuesV3WithValueString: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `added-sugars` NutrientValuesV3WithValueString: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `proteins` NutrientValuesV3WithValueString: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `vitamin-d` NutrientValuesV3WithValueString: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `calcium` NutrientValuesV3WithValueString: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `iron` NutrientValuesV3WithValueString: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
          - `potassium` NutrientValuesV3WithValueString: Quantity of a nutrient (per 100g, per 100ml or per serving) in a standard unit (g or ml)
            - `value_string` string: A string representing the value of the quantity.
            - `value` number: A normalized float value for the quantity, computed from `value_string` if it exists.
            - `value_computed` number: A normalized float value for the quantity, computed by the system (not entered by a user or manufacturer). This is used only for values that are computed from other nutrient values, like energy computed from fat, carbohydrates and proteins. And salt or sodium computed from each other.
            - `unit` string: The unit of the value entered by the contributor (a user or the manufacturer), for the product. In most cases, this unit is the unit displayed on the product for the nutrient, but it is not guaranteed, as some apps may force specific units when writing nutrient values. The possible values depends on the nutrient. * `g` for grams * `mg` for milligrams * `μg` for micrograms * `cl` for centiliters * `ml` for mililiters * `dv` for recommended daily intakes (aka [Dietary Reference Intake](https://en.wikipedia.org/wiki/Dietary_Reference_Intake)) * `% vol` for alcohol vol per 100 ml 🤓 code: see the [Units module][units-module], and [Food:default_unit_for_nid function][default-unit] [units-module]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Units.html [default-unit]: https://openfoodfacts.github.io/openfoodfacts-server/dev/ref-perl-pod/ProductOpener/Food.html#default_unit_for_nid_(_%24nid)
            - `modifier` '<' | '<=' | '~' | '>=' | '>': This property is optional.
        - `preparation` 'as_sold' | 'prepared': Indicates whether the nutrition values refer to the product *as_sold* or *prepared*. The preparation state affects nutrient values.
        - `per` '100g' | '100ml' | 'serving': The nutrition data on the package can be per serving, per 100g or per 100ml. This is essential to understand if values in the `nutrients` object apply for a serving, for 100g or for 100ml.
        - `per_quantity` number: The nutrition data on the package can be per serving, per 100g or per 100ml. When the data is given per serving, the actual quantity that defines one serving may vary between products and is stored in this field. This is essential to understand to which quantity values in `nutrients` apply for. For example, if the label states "per 250g", then this field should be *250*.
        - `per_unit` string: The nutrition data on the package can be per serving, per 100g or per 100ml. When the data is given per serving, the actual unit that defines one serving may vary between products and is stored in this field. This is essential to understand to which quantity values in `nutrients` apply for. For example, if the label states "per 250g", then this field should be *g*.
        - `source` string: The nutrition data of products can be obtained through several sources.
        - `source_description` string: A description of the source used for this nutrition set. This provides more information on how and when the source was used. This property is optional.
        - `last_updated_t` integer: A timestamp indicating when this nutrition set was last updated.
        - `unspecified_nutrients` string[]: A list of nutrients that are typically present, but that are not specified for this particular product, especially for packaging source. This property is optional.
    - `nutriscore` Nutriscores
      - `2021` object
        - `category_available` 0 | 1
        - `grade` 'a' | 'b' | 'c' | 'd' | 'e': Nutri-Score for the product as a letter. See https://world.openfoodfacts.org/nutriscore.
        - `nutrients_available` 0 | 1
        - `nutriscore_applicable` 0 | 1
        - `nutriscore_computed` 0 | 1
        - `score` integer
        - `data` Nutriscore2021Data
          - `is_beverage` 0 | 1
          - `is_cheese` 0 | 1
          - `is_water` 0 | 1
          - `is_fat` 0 | 1
          - `energy` integer
          - `energy_points` integer
          - `energy_value` integer
          - `fiber` number, float
          - `fiber_points` integer
          - `fiber_value` number, float
          - `fruits_vegetables_nuts_colza_walnut_olive_oils` number, float
          - `fruits_vegetables_nuts_colza_walnut_olive_oils_points` integer
          - `fruits_vegetables_nuts_colza_walnut_olive_oils_value` number, float
          - `proteins` number, float
          - `proteins_points` integer
          - `proteins_value` number, float
          - `saturated_fat` number, float
          - `saturated_fat_points` integer
          - `saturated_fat_value` number, float
          - `sodium` number, float
          - `sodium_points` integer
          - `sodium_value` number, float
          - `sugars` number, float
          - `sugars_points` integer
          - `sugars_value` number, float
          - `negative_points` integer
          - `positive_points` integer
          - `grade` 'a' | 'b' | 'c' | 'd' | 'e': Nutri-Score for the product as a letter. See https://world.openfoodfacts.org/nutriscore.
          - `score` integer
      - `2023` object
        - `category_available` 0 | 1
        - `grade` 'a' | 'b' | 'c' | 'd' | 'e': Nutri-Score for the product as a letter. See https://world.openfoodfacts.org/nutriscore.
        - `nutrients_available` 0 | 1
        - `nutriscore_applicable` 0 | 1
        - `nutriscore_computed` 0 | 1
        - `score` integer
        - `data` Nutriscore2023Data
          - `is_beverage` 0 | 1
          - `is_cheese` 0 | 1
          - `is_water` 0 | 1
          - `is_fat_oil_nuts_seeds` 0 | 1
          - `is_red_meat_product` 0 | 1
          - `components` object
            - `negative` NutriscoreComponent[]
              - …
            - `positive` NutriscoreComponent[]
              - …
          - `count_proteins` number, float
          - `count_proteins_reason` string
          - `negative_points` integer
          - `positive_points` integer
          - `negative_points_max` integer
          - `positive_points_max` integer
          - `positive_nutrients` string[]
    - `nutriscore_2021_tags` NutriscoreGrade[]
    - `nutriscore_2023_tags` NutriscoreGrade[]
    - `nutriscore_data` Nutriscore2021Data
      - `is_beverage` 0 | 1
      - `is_cheese` 0 | 1
      - `is_water` 0 | 1
      - `is_fat` 0 | 1
      - `energy` integer
      - `energy_points` integer
      - `energy_value` integer
      - `fiber` number, float
      - `fiber_points` integer
      - `fiber_value` number, float
      - `fruits_vegetables_nuts_colza_walnut_olive_oils` number, float
      - `fruits_vegetables_nuts_colza_walnut_olive_oils_points` integer
      - `fruits_vegetables_nuts_colza_walnut_olive_oils_value` number, float
      - `proteins` number, float
      - `proteins_points` integer
      - `proteins_value` number, float
      - `saturated_fat` number, float
      - `saturated_fat_points` integer
      - `saturated_fat_value` number, float
      - `sodium` number, float
      - `sodium_points` integer
      - `sodium_value` number, float
      - `sugars` number, float
      - `sugars_points` integer
      - `sugars_value` number, float
      - `negative_points` integer
      - `positive_points` integer
      - `grade` 'a' | 'b' | 'c' | 'd' | 'e': Nutri-Score for the product as a letter. See https://world.openfoodfacts.org/nutriscore.
      - `score` integer
    - `nutriscore_grade` 'a' | 'b' | 'c' | 'd' | 'e': Nutri-Score for the product as a letter. See https://world.openfoodfacts.org/nutriscore.
    - `nutriscore_score` integer: Nutri-Score for the product as an integer (see also `nutriscore_grade`).
    - `nutriscore_score_opposite` integer
    - `nutriscore_tags` NutriscoreGrade[]
    - `nutriscore_version` string
    - `data_quality_bugs_tags` string[]
    - `data_quality_errors_tags` string[]
    - `data_quality_info_tags` string[]
    - `data_quality_tags` string[]
    - `data_quality_warnings_tags` string[]
    - `data_sources` string: Source of data imported from producers.
    - `data_sources_tags` string[]
    - `last_check_dates_tags` string[]
    - `last_checked_t` integer
    - `last_checker` string
    - `states` string: comma separated list of values indicating some states of the product, like things to be done, or to be completed. See [states taxonomy](https://static.openfoodfacts.net/data/taxonomies/states.json)
    - `states_hierarchy` string[]
    - `states_tags` string[]
    - `misc_tags` string[]: Information about different aspect of the product Refer to [misc taxonomy](https://static.openfoodfacts.org/data/taxonomies/misc.json)
    - `additives_original_tags` string[]
    - `additives_prev_original_tags` string[]
    - `added_countries_tags` object[]
    - `allergens_from_ingredients` string
    - `allergens_from_user` string
    - `amino_acids_prev_tags` object[]
    - `amino_acids_tags` object[]
    - `carbon_footprint_percent_of_known_ingredients` integer
    - `categories_properties` object
      - `agribalyse_food_code:en` string
      - `agribalyse_proxy_food_code:en` string
      - `ciqual_food_code:en` string
    - `categories_properties_tags` string[]
    - `category_properties` object
    - `ciqual_food_name_tags` string[]
    - `compared_to_category` string: the category to use for comparison. **TODO** explain how it is chosen.
    - `forest_footprint_2026` ProductForestFootprint2026: Forest footprint (2026 algorithm) of a product — the risk of deforestation associated with its ingredients. This is a computed field. See also `forest_footprint_2026.grade`, `forest_footprint_2026.summary`, `forest_footprint_2026.total_footprint_per_kg`, and `forest_footprint_2026.primary_ingredients`.
      - `grade` 'a' | 'b' | 'c' | 'd' | 'unknown' | 'not_computed': Overall forest footprint grade of the product. - `a`: No deforestation risk (absence of risky ingredients or zero impact) - `b`: Low risk of deforestation - `c`: Medium risk of deforestation - `d`: High risk of deforestation - `unknown`: The product has ingredients that are not yet assessed (e.g. corn, rice, cassava, soya, meat, dairy) without any computed primary ingredients - `not_computed`: The product contains risky ingredients but the overall grade could not be computed
      - `summary` 'missing_ingredients' | 'with_other_risky_ingredients' | 'without_primary_ingredients_or_other_risky_ingredients' | 'with_primary_ingredients': Summary of the forest footprint computation status: - `missing_ingredients`: The product has no ingredients list, so the forest footprint could not be computed - `with_other_risky_ingredients`: The product contains risky ingredients (not yet assessed) but no computed primary ingredients - `without_primary_ingredients_or_other_risky_ingredients`: The product has ingredients but none are risky or assessed; grade is A - `with_primary_ingredients`: The product has computed primary ingredients (cocoa, coffee, palm oil, chicken/eggs)
      - `total_footprint_per_kg` number, nullable: Total forest footprint per kilogram of food, in square meters per kg. This field is present (as a number) when the summary is `with_primary_ingredients` or `without_primary_ingredients_or_other_risky_ingredients`. It is `null` when the summary is `missing_ingredients` or `with_other_risky_ingredients`. It may be absent if the field was not populated.
      - `primary_ingredients` object: Map of primary ingredients and their computed forest footprint details. Keys are primary ingredient tags (`en:cocoa`, `en:coffee`, `en:palm-oil`, `en:chicken-and-eggs`, `en:other-risky-ingredients`). Only primary ingredients present in the product are included.
    - `conservation_conditions` string
    - `customer_service` string: Contact info of customer service.
    - `expiration_date` string
    - `link` string: link to the product on the website of the producer
    - `main_countries_tags` object[]
    - `minerals_prev_tags` object[]
    - `minerals_tags` object[]
    - `owner_fields` object: Those are fields provided by the producer (through producers platform), and the value he provided.
      - `additionalProperties` union: you can retrieve all kind of properties, the same as on the parent object (the product). It's not processed entries (like tags for example) but raw ones.
        - integer
        - string
        - object
    - `nova_groups_markers` object: Detail of ingredients or processing that makes the products having Nova 3 or 4
    - `nucleotides_tags` object[]
    - `origin` string
    - `purchase_places` string: Country, state, or city where the product can be purchased.
    - `purchase_places_tags` string[]
    - `stores` string: Distributor name.
    - `stores_tags` string[]
    - `traces_from_ingredients` string
    - `traces_from_user` string
    - `created_t` integer, required: Date when the product was added (UNIX timestamp format). See also `entry_dates_tags`
    - `creator` string, required: The contributor who added the product first.
    - `editors_tags` string[]: List of editors who edited the product.
    - `informers_tags` string[]
    - `interface_version_created` string
    - `interface_version_modified` string
    - `languages` object
    - `languages_codes` object: Same as `languages` but by language code, instead of language tags
    - `languages_hierarchy` string[]
    - `languages_tags` string[]
    - `last_edit_dates_tags` string[]
    - `last_editor` string
    - `last_modified_by` string, required: The username of the user who last modified the product.
    - `last_modified_t` integer, required: Date when the product page was last modified. This date is updated only when primary data is modified (data entered by the user or updated by an interface)
    - `last_updated_t` integer, required: Date when the product page was last modified. This date is updated when primary data or secondary data is modified (primary: data entered by a user or read from an interface, secondary: data computed by a utility such as update_all_products.pl)
    - `owner` string: Id of the producer in case he provides his own data about a product (producer platform).
    - `owners_tags` string: Tagyfied version of owner
    - `photographers_tags` string[]
    - `rev` integer, required: revision number of this product version (each edit adds a revision)
    - `sources` object[]
      - `fields` string[]
      - `id` string
      - `images` object[]
      - `import_t` integer
      - `manufacturer` union
        - integer
        - string
      - `name` string
      - `source_licence` string
      - `source_licence_url` string
      - `url` string, nullable
    - `sources_fields` object
      - `org-gs1` object
        - `gln` string
        - `gpcCategoryCode` string
        - `gpcCategoryName` string
        - `isAllergenRelevantDataProvided` string
        - `lastChangeDateTime` string
        - `partyName` string
        - `productionVariantDescription` string
        - `publicationDateTime` string
    - `teams` string
    - `teams_tags` string[]
    - `update_key` string
    - `knowledge_panels` Panels: The panels object is a dictionary of individual panel objects. Each key of the dictionary is the id of the panel, and the value is the panel object. Apps typically display a number of root panels with known panel ids (e.g. health_card and environment_card). Panels can reference other panels and display them as sub-panels.
    - `attribute_groups` object[]: Each element is an attribute that can help compute a personal ranking for the product
      - `id` string: Unique id of the attribute. It will be use to match against preferences parameters.
      - `status` 'known' | 'unknown': wether we have the information to really compute this criteria or not.
      - `title` string: A descriptive sentence about the situation of the product concerning attribute
      - `match` number, float: a numeric value for the match, telling how much the products ranks well for this particular attribute. The higher the value, the better the match.
      - `grade` 'unknown' | 'a' | 'b' | 'c' | 'd' | 'e': every attribute as a grade for a to e
      - `name` string: The name of attribute, for eventual display
      - `icon_url` string: an icon representing the attribute match (often using a color)
      - `description` string: An eventual description of the value of the property upon which this attribute is based
      - `description_short` string: An eventual short description of the value of the property upon which this attribute is based

## Changes

- **2026-11-18** (v3) `ab04ff78cb83`: 4 breaking, 1 warning, 3 info
  - added `#/components/schemas/lc_cc, #/components/schemas/fields_tags_lc` to the request body `allOf` list
  - added `#/components/schemas/product_type, #/components/schemas/tags-write, subschema #3` to the `allOf[subschema #3]/product` request property `allOf` list
  - the `allOf[subschema #3]/product` request property type changed from no type to `object`
  - the `allOf[subschema #2]/product` response's property type changed from no type to `object` for status `200`
  - …4 more

[Operation history](https://skmtc.dev/openfoodfacts/apis/open-food-facts-open-api-v3-under-development/changes/api/v3/product/:code/patch.md)

---

[API](https://skmtc.dev/openfoodfacts/apis/open-food-facts-open-api-v3-under-development.md) - [All operations](https://skmtc.dev/openfoodfacts/apis/open-food-facts-open-api-v3-under-development/llms.txt) - [OpenAPI document](https://skmtc.dev/openfoodfacts/apis/open-food-facts-open-api-v3-under-development/revisions/ab04ff78cb83?raw)
