Date Format in Europe: Country Table, ISO 8601, Parsing

European countries write dates day first, then month, then year: 31/12/2026 in the United Kingdom (UK) and France, 31.12.2026 in Germany and Austria. Sweden and Lithuania write the year first (2026-12-31), and Hungary writes 2026. 12. 31. For data exchanged between systems, use ISO 8601, the International Organization for Standardization (ISO) date standard (ISO 8601-1:2019), which writes 2026-12-31.

Key takeaways

• Order: day, month, year in most of Europe. Year first in Sweden, Lithuania and Hungary.
• Separators differ: slashes in the UK, France, Italy, Spain and Portugal. Dots in Germany, Austria and Poland. Hyphens in the Netherlands.
• Ambiguity: 05/06/2026 is 5 June in Europe and 6 May in the United States (US). The string does not show which one it is.
• Storage rule: parse with the source's format when data comes in, store ISO 8601 in Coordinated Universal Time (UTC), and format for the reader only on screen.

Date format by country

Each country has its own everyday date format, and the day-month-year order is shared more than the separators. The "CLDR short" column shows what the Unicode Common Locale Data Repository (CLDR) produces for 5 January 2026, which browsers and most operating systems print. The "common" column shows how people write the date by hand.

Country	Locale	CLDR short	Common numeric format
United Kingdom	en-GB	05/01/2026	dd/mm/yyyy
Ireland	en-IE	05/01/2026	dd/mm/yyyy
France	fr-FR	05/01/2026	dd/mm/yyyy
Germany	de-DE	05.01.26	dd.mm.yyyy
Austria	de-AT	05.01.26	dd.mm.yyyy
Switzerland	de-CH, fr-CH	05.01.26	dd.mm.yyyy
Italy	it-IT	05/01/26	dd/mm/yyyy
Spain	es-ES	5/1/26	d/m/yyyy (no leading zeros)
Portugal	pt-PT	05/01/26	dd/mm/yyyy
Netherlands	nl-NL	05-01-2026	dd-mm-yyyy (hyphens)
Belgium (Dutch)	nl-BE	5/01/2026	d/mm/yyyy
Belgium (French)	fr-BE	5/01/26	d/mm/yyyy
Poland	pl-PL	5.01.2026	d.mm.yyyy
Czechia	cs-CZ	05.01.26	d. m. yyyy (with spaces)
Hungary	hu-HU	2026. 01. 05.	yyyy. mm. dd. (year first, trailing dot)
Sweden	sv-SE	2026-01-05	yyyy-mm-dd (ISO)
Denmark	da-DK	05.01.2026	dd.mm.yyyy
Norway	nb-NO	05.01.2026	dd.mm.yyyy
Finland	fi-FI	5.1.2026	d.m.yyyy
Lithuania	lt-LT	2026-01-05	yyyy-mm-dd (ISO)
Latvia	lv-LV	05.01.26	dd.mm.yyyy
Estonia	et-EE	05.01.26	dd.mm.yyyy
Bulgaria	bg-BG	5.01.26 г.	d.mm.yyyy г. ("г." means year)
Greece	el-GR	5/1/26	d/m/yyyy
Romania	ro-RO	05.01.2026	dd.mm.yyyy

Three patterns cover the continent:

• Slashes, day first: UK, Ireland, France, Italy, Spain, Portugal, Belgium, Greece.
• Dots, day first: Germany, Austria, Switzerland, Poland, Czechia, the Nordic countries except Sweden, the Baltic countries except Lithuania, Bulgaria, Romania.
• Year first: Sweden and Lithuania with ISO hyphens, Hungary with dots and spaces.

The Netherlands is the exception to the slash and dot groups: nl-NL prints day first with hyphens (05-01-2026).

What is the date format in Austria?

Austria writes 31.12.2026, with dots and the day first, the same as Germany. A parser for Austrian input should accept one or two digits for the day and the month (5.1.2026 and 05.01.2026). Austrian German also writes "Jänner" for January, which a German month-name parser does not recognise.

What is the date format in Spain?

Spain writes 31/12/2026, with slashes and the day first. The CLDR short format drops leading zeros (5/1/26 is 5 January), so a parser should accept both widths. Written out, the month name is lowercase and joined with "de": 5 de enero de 2026.

What is the date format in Belgium?

Belgium writes 31/12/2026, with slashes and the day first, like France. Both Belgian locales, Dutch (nl-BE) and French (fr-BE), keep the zero in the month and drop the zero in the day (5/01), so exports have mixed widths. The year length differs: nl-BE prints 5/01/2026 and fr-BE prints 5/01/26.

What is the date format in Bulgaria?

Bulgaria writes 5.01.2026 г., with dots and the day first, and the month keeps its zero. The suffix "г." is short for година, which means year. Strip this suffix before you parse the date, because a plain day, month and year pattern rejects it with an error.

Is the European date format different from the US format?

Yes. Europe writes the day first (31/12/2026) and the US writes the month first (12/31/2026). For any date where both numbers are 12 or lower, one string has two valid meanings: 05/06/2026 is 5 June in London and 6 May in New York.

The string does not show which meaning applies. Two things resolve it: the source of the data, or a value above 12 in the first position elsewhere in the same file. If neither exists, the date is ambiguous and a program must not guess. This is why the safest internal format has no ambiguity at all.

How do you write dates in words in European languages?

Write the month as a word and the year with four digits. A written month removes the ambiguity for human readers. The World Wide Web Consortium (W3C) recommends this form for content that readers in several countries will see (W3C: Date formats).

Language	Written date
English (UK)	31 December 2026
French	31 décembre 2026
German	31. Dezember 2026
Spanish	31 de diciembre de 2026
Italian	31 dicembre 2026
Dutch	31 december 2026

Three details differ by language. German puts a dot after the day because it marks an ordinal (the 31st). French, Spanish, Italian and Dutch write month names in lowercase. UK English drops the "st", "nd" or "th" suffix in formal writing, so "31 December" and not "31st December".

What is the ISO 8601 date format in the EU?

ISO 8601 writes dates as YYYY-MM-DD (2026-12-31), and the standard in force is ISO 8601-1:2019 (ISO: ISO 8601 date and time format). The European standards bodies CEN and CENELEC adopted it as EN 28601, now EN ISO 8601. The format sorts correctly as plain text.

Germany shows the split between data and people. The German office-writing standard DIN 5008 (Deutsches Institut für Normung) added the ISO form in 1995 and allowed the traditional 31.12.2026 again in 2001 (Wikipedia: Date and time notation in Europe).

People still read national day-first dates, and systems exchange ISO. Software follows the same split: ISO inside, the reader's format on screen.

How do European time, week numbers and week start days differ?

Most European locales use the 24-hour clock and start the week on Monday, as ISO 8601 does. The US uses a 12-hour clock and starts the week on Sunday. Three details differ between European countries, and each one can break a parser or a calendar.

• 24-hour clock: most European locales format time as 14:30. Finnish and Danish use a dot (14.30). CLDR defaults Greece to a 12-hour clock (2:30 μ.μ.). The UK and Ireland use both styles.
• First day of the week: the CLDR week starts on Monday in the countries in the table above, except Portugal, where it starts on Sunday. US calendars start on Sunday.
• Week numbers: ISO week 1 is the week that contains the year's first Thursday. German calendars print these numbers and German business uses them. A value like 2026-W53 is valid ISO 8601, so a parser that expects only calendar dates rejects it.

How do you parse European dates in Python?

Parse with the source locale's format when data comes in, store ISO 8601 in UTC, and format back to a locale only when you show the date to a person. Every service in between then sees only ISO. The code below was run on Python 3 and returns the output shown.

Step 1: How do you map locales to format strings?

Use a dictionary that maps each locale code to a strptime pattern. The source locale decides the pattern, never the content of the string. The dictionary below covers the 15 locales that need different patterns, and you can add a locale by adding one line.

LOCALE_FORMATS = {
    "en_GB": "%d/%m/%Y",
    "fr_FR": "%d/%m/%Y",
    "it_IT": "%d/%m/%Y",
    "es_ES": "%d/%m/%Y",
    "pt_PT": "%d/%m/%Y",
    "de_DE": "%d.%m.%Y",
    "de_AT": "%d.%m.%Y",
    "pl_PL": "%d.%m.%Y",
    "da_DK": "%d.%m.%Y",
    "nb_NO": "%d.%m.%Y",
    "fi_FI": "%d.%m.%Y",
    "nl_NL": "%d-%m-%Y",
    "sv_SE": "%Y-%m-%d",
    "lt_LT": "%Y-%m-%d",
    "hu_HU": "%Y. %m. %d.",
}

Python's strptime accepts single-digit days and months for %d and %m, so 5.1.2026 and 05.01.2026 both parse with %d.%m.%Y. Hungarian dates need the spaces and the trailing dot in the pattern.

Step 2: How do you parse a date with its source locale?

Look up the pattern for the locale, then call strptime with the stripped input string. Reject an unknown locale with an error instead of falling back to a default order, because a silent default hides a wrong day and month order.

from datetime import datetime


def parse_european_date(date_str: str, locale: str) -> datetime:
    fmt = LOCALE_FORMATS.get(locale)
    if not fmt:
        raise ValueError(f"Unsupported locale: {locale}")
    return datetime.strptime(date_str.strip(), fmt)


print(parse_european_date("27.05.2026", "de_DE").date().isoformat())  # 2026-05-27
print(parse_european_date("2026. 05. 27.", "hu_HU").date().isoformat())  # 2026-05-27

Step 3: How do you put the parser behind an API?

Wrap the function in a FastAPI endpoint, and any workflow can call it as an application programming interface (API). A valid date returns the ISO string, and an invalid date or unknown locale returns HTTP status 422 with the error message.

from fastapi import FastAPI, HTTPException

app = FastAPI()


@app.get("/parse")
def parse_date(date_str: str, locale: str):
    try:
        parsed = parse_european_date(date_str, locale)
    except ValueError as e:
        raise HTTPException(422, detail=str(e))
    return {"iso": parsed.date().isoformat(), "original": date_str, "locale": locale}

On CodeWords you describe this service to Cody in plain language ("an API that takes a European date and a locale code and returns ISO 8601"). Cody builds it, you review it, and you deploy it.

How do you parse European dates in JavaScript?

Pass an explicit pattern to a parser. new Date("27/05/2026") returns Invalid Date in Chrome and Firefox, because the built-in parser guarantees only ISO strings. With the date-fns library, call parse("27/05/2026", "dd/MM/yyyy", new Date()) instead. The pattern tells the parser which part is the day, so the result no longer depends on the browser.

To show a date in a reader's format, use Intl.DateTimeFormat, which reads the same CLDR data as the table above. A date-only ISO string is UTC midnight, so format it in UTC. Otherwise a reader west of UTC sees the previous day.

new Intl.DateTimeFormat("de-AT", { dateStyle: "short", timeZone: "UTC" }).format(
  new Date("2026-12-31T00:00:00Z"),
);
// "31.12.26"

How do you read European dates in CSV and Excel files?

Read every date column as text, then convert it with one exact format. A comma-separated values (CSV) file has no type information, so each date is plain text in the format of the machine that exported it. Excel stores dates as serial numbers and shows them in the computer's regional format.

The same .xlsx file shows 05/06/2026 on a UK laptop and 6/5/2026 on a US laptop. With pandas, use dtype=str and an explicit format:

import pandas as pd

df = pd.read_csv("eu_sales_data.csv", dtype=str)
for col in ["order_date", "ship_date"]:
    df[col] = pd.to_datetime(df[col], format="%d/%m/%Y")  # raises ValueError on a non-matching row

An explicit format raises an error on a row that does not match, which is what you want. The dayfirst=True option is weaker: the pandas documentation states it "is not strict, but will prefer to parse with day first" (pandas.to_datetime documentation). Passing date_format to read_csv is not a substitute. If one value does not match, pandas leaves the whole column as text without an error.

After parsing, check for dates in the future or far in the past. These are the usual sign of a swapped day and month.

If the file arrives in Google Drive every day, a scheduled CodeWords workflow can pick it up, parse the dates with the source format, and write clean ISO dates to Google Sheets. The guides on JavaScript Object Notation (JSON) date formats and sorting by date in Google Sheets cover the next steps.

Which date edge cases break parsers?

Five cases cause most date errors in European data. The first four are input problems that a strict format catches with an error. The fifth, ambiguity, does not raise an error, so it needs a decision rule. The two sections after the list give that rule.

• Two-digit years: Python's %y maps 00 to 68 to 2000 to 2068, and 69 to 99 to 1969 to 1999. A birth date of 05/06/65 becomes 2065.
• Missing leading zeros: 5/1/2026 from Spain or Finland. Check that the parser accepts single digits.
• Mixed sources in one file: someone pastes US rows into a European sheet, and the dates flip halfway down.
• Suffixes and trailing dots: Hungarian "2026. 01. 05." and Bulgarian "5.01.2026 г." fail a plain pattern.
• Ambiguous dates: 05/06/2026 is 5 June or 6 May. Only the source tells you.

How do you flag ambiguous dates?

Flag a date as ambiguous when the first two parts are both 12 or lower and are not equal, because only then can the string mean two different days. Year-first dates are never ambiguous. A value with text in the first two parts, such as "5. Jan. 2026", is also flagged, so a person checks it. Do not guess the order. Send flagged values to a person.

import re


def is_ambiguous(date_str: str) -> bool:
    parts = [p for p in re.split(r"[./\- ]+", date_str.strip()) if p]
    if len(parts) != 3 or len(parts[0]) == 4:
        return False  # year-first ISO and Hungarian dates are not ambiguous
    if not (parts[0].isdigit() and parts[1].isdigit()):
        return True  # month names or other text: send to review
    first, second = int(parts[0]), int(parts[1])
    return first <= 12 and second <= 12 and first != second

When it returns True and you have no source metadata, send the record to a review queue. A CodeWords workflow can post the record to Slack for someone to confirm.

How do you find the date order of an undocumented feed?

Scan a sample for a value above 12. A first part above 12 is a day, so the order is day first. A second part above 12 is a day, so the order is month first. A four-digit first part is a year, so the order is year first (2026-12-31 or Hungarian 2026. 12. 31.).

def infer_date_order(dates: list[str]) -> str:
    saw_year_first = False
    for d in dates:
        parts = [p for p in re.split(r"[./\- ]+", d.strip()) if p]
        if len(parts) != 3 or not parts[0].isdigit():
            continue
        if len(parts[0]) == 4:
            saw_year_first = True
            continue
        if int(parts[0]) > 12:
            return "day_first"
        if parts[1].isdigit() and int(parts[1]) > 12:
            return "month_first"
    if saw_year_first:
        return "year_first"
    return "unknown"

Store the result as configuration for that source, so the workflow does not guess again on every run. Decide in this order: source metadata first, a sample scan second, human review last.

Frequently asked questions

What is the date format in Europe?

Most European countries write dates day, month, year, as 31/12/2026 or 31.12.2026. Sweden and Lithuania write 2026-12-31, and Hungary writes 2026. 12. 31. For data, the standard is ISO 8601 (ISO 8601-1:2019), which writes 2026-12-31 and is unambiguous across systems and languages.

Is it dd/mm/yyyy or mm/dd/yyyy in Europe?

Europe uses dd/mm/yyyy, with the day first. The US is the main place that writes the month first, so 05/06/2026 means 5 June in Europe and 6 May in the US. Only a value above 12 in the first position proves the order of a single date string.

Which European countries write the year first?

Sweden, Lithuania and Hungary write the year first. Sweden and Lithuania use ISO hyphens (2026-12-31), and Hungary uses dots and spaces (2026. 12. 31.). Every other country in the table above writes the day first, with slashes, dots or hyphens as separators.

What is the EU date format?

No single format exists, because each European Union (EU) country keeps its own everyday format. The shared standard for data is EN ISO 8601, which writes dates as YYYY-MM-DD. The European standards bodies CEN and CENELEC adopted it from ISO 8601 as EN 28601, according to Wikipedia.

What is the date format in Germany?

Germany writes 31.12.2026, with dots and the day first. The German office-writing standard DIN 5008 also allows the ISO form 2026-12-31 (added 1995, with the dotted form allowed again in 2001). The CLDR short date uses a two-digit year, as in 05.01.26.

What is the date format in Austria?

Austria writes 31.12.2026, with dots and the day first, the same as Germany. Austrian German writes January as "Jänner". When you parse Austrian input, accept one or two digits for the day and the month, because both 5.1.2026 and 05.01.2026 occur.

What is the date format in France, Spain and Italy?

All three write the day first with slashes: 31/12/2026. In CLDR short style, France prints 05/01/2026, Italy prints 05/01/26, and Spain prints 5/1/26 without leading zeros. A parser for these countries should accept one or two digits for the day and month.

Does the UK use the European date format?

Yes, the UK uses the day-first order that most of Europe uses. The UK writes 31/12/2026, with slashes, the same as France and Ireland. The US is the main English-speaking country that writes the month first, so 05/06/2026 means 5 June in the UK.

Why does Hungary write the year first?

Hungary has traditionally written dates from the largest unit to the smallest: year, month, day. The format is 2026. 12. 31., with a dot after each part. This is the same order as ISO 8601, but the dots and spaces differ from ISO hyphens, so a parser needs its own pattern.

What is the difference between the EU format and ISO 8601?

The everyday European format is day first (31/12/2026) and is written for people. ISO 8601 is year first (2026-12-31) and is written for data. ISO 8601 is unambiguous, and it sorts correctly as plain text, so systems should store and exchange ISO and show the local format to readers.

How do I convert a European date to ISO 8601 in Python?

Parse the string with its source format, then call isoformat(). For a German date, datetime.strptime("27.05.2026", "%d.%m.%Y").date().isoformat() returns 2026-05-27. Choose the format from the source locale, not from the string, because a day-first and a month-first pattern can both accept the same value.

Can JavaScript's Date constructor parse European dates?

No. new Date("27/05/2026") returns Invalid Date, because the built-in parser guarantees only ISO strings. Parse the string with an explicit pattern using a library such as date-fns, or split the string yourself and pass the year, month and day as numbers.

How do I write dates for a European audience without confusing anyone?

Write the month as a word and the year with four digits, as in 31 December 2026. A written month cannot be read two ways. In technical contexts such as logs, files and APIs, use ISO 8601 (2026-12-31), which every system parses the same way.

Related reading

• JSON date format: ISO 8601, timestamps, parsing
• How to sort by date in Google Sheets
• Import a CSV into Google Sheets
• CodeWords integrations and templates