₩

KRW — South Korean Won

fiat
ISO Code: KRWNumeric: 410ISO minor unit: 0Region: Asia
🇰🇷

Developer Note

No minor unit.

Verified 2026-09-27. Primary source

How 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;
// → 0

Korean 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

Valueen-US
1₩1
9.99₩10
100₩100
1234.56₩1,235
1000000₩1,000,000

Intl.NumberFormat

JavaScript
// 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 × 1

Countries Using KRW