KRW — South Korean Won
fiatHow to implement KRW safely
Won uses ISO 4217 alpha code KRW and numeric code 410.
KRW appears in the current ISO 4217 list published 2026-09-17. KRW has ISO minor unit 0, so the standard currency formatter normally displays no fractional digits. Configure Intl.NumberFormat with currency: "KRW"; do not hardcode the symbol or assume every currency uses two decimals.
₩ is the reference symbol in this dataset. Store KRW alongside the amount so exports, payments, and accounting data remain unambiguous. Format for display only after choosing the user's locale, because symbol placement and separators belong to the locale rather than the currency record.
This site's coverage associates KRW with one country or territory: South Korea (KR). Region and language still need separate locale selection; the currency code alone does not choose punctuation or digit shapes. The record was checked against the SIX ISO 4217 source on 2026-09-27; recheck status-sensitive records when the Maintenance Agency publishes a new list.
- Status: active
- Numeric code: 410
- ISO minor unit: 0
- Verified: 2026-09-27
Reviewed 19 July 2026. Sources: SIX ISO 4217 current list
Common mistakes with KRW
- Don't show .00. KRW normally displays no fractional digits.
- In ko-KR the symbol goes immediately before the amount (₩1,234,568). Let the locale place it rather than concatenating strings.
How to format KRW
Pass currency: 'KRW' and Intl prints the won sign ₩ (U+20A9) before the amount with no space and no decimals. ko-KR and en-US give the same string. VND also has no minor unit, so what separates the two is placement and punctuation:
new Intl.NumberFormat('ko-KR', { style: 'currency', currency: 'KRW' }).format(1234567);
// → "₩1,234,567"
new Intl.NumberFormat('en-US', { style: 'currency', currency: 'KRW' }).format(1234567);
// → "₩1,234,567"
new Intl.NumberFormat('vi-VN', { style: 'currency', currency: 'VND' }).format(1234567);
// → "1.234.567 ₫" (U+00A0 before ₫)
new Intl.NumberFormat('ko-KR', { style: 'currency', currency: 'KRW' }).resolvedOptions().maximumFractionDigits;
// → 0Korean amounts group with commas and put the sign first. Vietnamese amounts group with periods and put the sign last, after a no-break space. Reusing one template for both gets at least one of them wrong.
₩ or 원?
Both appear in Korean, in different roles. In Intl, ₩ is the symbol in all four locales tested (ko-KR, en-US, ja-JP, zh-CN). 원 only appears in the currency name:
new Intl.NumberFormat('ko-KR', { style: 'currency', currency: 'KRW', currencyDisplay: 'name' }).format(1234567);
// → "1,234,567 대한민국 원"
new Intl.NumberFormat('en-US', { style: 'currency', currency: 'KRW', currencyDisplay: 'name' }).format(1234567);
// → "1,234,567 South Korean won"
new Intl.NumberFormat('ko-KR', { style: 'currency', currency: 'KRW', currencyDisplay: 'code' }).format(1234567);
// → "KRW 1,234,567" (U+00A0 after KRW)In running Korean text, 원 is a unit noun written after the number. The Hangul orthography (Art. 43) spaces unit nouns but allows them to attach when written with numerals, and its own example is 80원. No Intl option produces 1,234,567원. If Korean UI copy calls for that form, format the number without the currency style, add 원 in ko-KR only, and keep KRW in the data:
new Intl.NumberFormat('ko-KR').format(1234567) + '원';
// → "1,234,567원"Compact notation: 천, 만, 억, 조
Korean counts large numbers in steps of ten thousand (만, 10⁴), then 억 (10⁸) and 조 (10¹²). When numbers are written out with these unit words, the Hangul orthography puts a space at each 만 step. Art. 44 reads "수를 적을 적에는 ‘만(萬)’ 단위로 띄어 쓴다" (write numbers with a space at each 만 unit), with the example 12억 3456만 7898. The official commentary adds that amounts of money are customarily written without spaces, to prevent alteration (일금: 삼십일만오천육백칠십팔원정). This is a spelling rule for written-out numbers. It doesn't change the comma grouping in ₩1,234,567. Unlike Japanese, ko-KR also abbreviates thousands (천).
const ko = new Intl.NumberFormat('ko-KR', { notation: 'compact' });
ko.format(1234); // → "1.2천"
ko.format(12345); // → "1.2만"
ko.format(1234567); // → "123만"
ko.format(123456789); // → "1.2억"
ko.format(1234567890123); // → "1.2조"
ko.format(9999); // → "1만"
new Intl.NumberFormat('ko-KR', { style: 'currency', currency: 'KRW', notation: 'compact' }).format(350000000);
// → "₩3.5억"
new Intl.NumberFormat('en-US', { style: 'currency', currency: 'KRW', notation: 'compact' }).format(1234567);
// → "₩1.2M"
new Intl.NumberFormat('vi-VN', { notation: 'compact' }).format(1234567);
// → "1,2 Tr"- 1,234,567 won is
123만in ko-KR. Don't translate "1.2M" by hand. Pass the locale. - Compact output is rounded: 9,999 prints as
1만. Use it for labels and charts, never for prices someone pays.
Q&A
Is it ₩ or 원?
Use ₩ (or the code KRW) wherever Intl formats the amount. 원 is the Korean word for the unit. It appears in currencyDisplay: 'name' output and, by orthography rule, after numerals in Korean prose (80원).
How is KRW formatting different from VND?
Neither currency has decimals (ISO 4217 minor unit 0 for both). ko-KR writes ₩1,234,567, sign first with comma grouping. vi-VN writes 1.234.567 ₫, with period grouping and the sign last after U+00A0. In compact form, ko-KR uses 123만 and vi-VN uses 1,2 Tr.
Is ₩ only the South Korean won?
No. ISO 4217 also lists the North Korean won (KPW, numeric 408). By default, Intl shows it as KPW 1,234. With currencyDisplay: 'narrowSymbol' it renders as ₩1,234, the same sign as KRW:
new Intl.NumberFormat('en-US', { style: 'currency', currency: 'KPW', currencyDisplay: 'narrowSymbol' }).format(1234);
// → "₩1,234"Runtimes disagree on KPW decimals. CLDR gives KPW 0 digits, so Node prints ₩1,234. ISO 4217 gives minor unit 2, and Bun 1.4.2 prints ₩1,234.00. If both currencies can appear, show codes.
Is the full-width ₩ the same character as ₩?
No. ₩ is U+FFE6 FULLWIDTH WON SIGN, a compatibility variant that Unicode maps to U+20A9. Normalise input before parsing, so '₩1,000'.normalize('NFKC') becomes "₩1,000".
Formatting Examples
| Value | en-US |
|---|---|
| 1 | ₩1 |
| 9.99 | ₩10 |
| 100 | ₩100 |
| 1234.56 | ₩1,235 |
| 1000000 | ₩1,000,000 |
Intl.NumberFormat
// Basic KRW formatting
new Intl.NumberFormat('en-US', {
style: 'currency',
currency: 'KRW',
}).format(1234.00);
// → "₩1,234"
// Minimum/maximum fraction digits
new Intl.NumberFormat('en-US', {
style: 'currency',
currency: 'KRW',
minimumFractionDigits: 0,
maximumFractionDigits: 0,
}).format(99);
// Example display precision: 0 decimal places
// ISO 4217 minor unit: 0
// Integer minor-unit storage
// KRW amount = value × 1Countries Using KRW
Continue your localization implementation
Connect this reference to the format, validation, and testing guidance used elsewhere on the site.
Formatting implementation
Numbers, currencies, dates, time zones, numbering systems, and production tests.
Failure patterns
Hardcoded copy, broken layouts, missing context, bidi, and cultural adaptation.
Standards reference
ISO country, currency, and language codes; BCP 47; E.164; and UPU S42.
Validation coverage
Provider evidence, country test cases, geocoding, deliverability, and phone checks.
Locale-aware numbers
Separators, grouping, currency precision, and Intl.NumberFormat patterns.
Localization testing
Pseudolocalization, test matrices, native review, and regional release gates.
Address and phone standards
UPU S42, E.164, adaptive forms, storage, parsing, and validation.
I18n architecture
Messages, Unicode, RTL, locale services, fallbacks, and delivery workflow.
Address formats
Country templates, field order, and accessible international forms.
Phone formats
E.164 storage, regional display, parsing, and validation.
Compare locales
Inspect the same numeric value across several country formats.
Interactive tools
Try number, address, and phone formatting in your browser.