numeral vs currency.js vs dinero.js vs currency-formatter
Choosing the Right Currency and Number Formatting Library for Production Apps
Search packages..
numeralcurrency.jsdinero.jscurrency-formatterSimilar Packages:

Choosing the Right Currency and Number Formatting Library for Production Apps

currency-formatter, currency.js, dinero.js, and numeral are JavaScript libraries designed to handle number formatting and currency representation, but they solve different problems with varying levels of strictness. numeral is a general-purpose number formatting tool that handles percentages, bytes, and time, but it relies on floating-point math which can cause calculation errors. currency-formatter focuses strictly on displaying currency strings based on ISO codes without handling math. currency.js attempts to solve floating-point errors for currency math using integer-based internal storage while offering flexible formatting. dinero.js (specifically version 1) provides an immutable, functional API for precise currency calculations and formatting, enforcing strict data integrity. Choosing the right one depends on whether you need simple display, complex math without rounding errors, or a general number formatter.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
numeral2,513,9299,703-3459 years agoMIT
currency.js808,8623,380-605 years agoMIT
dinero.js560,5016,793858 kB246 months agoMIT
currency-formatter143,091212-155 years agoMIT

Currency and Number Formatting Libraries: A Technical Deep Dive

When building financial dashboards, e-commerce checkouts, or invoicing systems, how you handle money matters. JavaScript's native number type uses floating-point arithmetic, which famously fails at simple decimal math (like 0.1 + 0.2). The libraries currency-formatter, currency.js, dinero.js, and numeral approach this problem from different angles. Some focus purely on how money looks, others on how it calculates, and some try to do both. Let's break down how they work in real engineering scenarios.

🧮 Calculation Safety: Floating Point vs. Integer Math

The biggest risk in financial code is precision loss. numeral uses standard JavaScript numbers, meaning it inherits all floating-point quirks. currency.js and dinero.js solve this by storing values as integers (cents) internally.

numeral is unsafe for money math. It formats well but calculates poorly.

import numeral from 'numeral';

// Dangerous: Floating point error
const val = numeral(0.1).value() + numeral(0.2).value();
console.log(val); // 0.30000000000000004

currency.js handles math safely by converting inputs to integers.

import currency from 'currency.js';

// Safe: Integer-based math
const val = currency(0.1).add(0.2);
console.log(val.value); // 0.3
console.log(val.intValue); // 30 (stored as cents)

dinero.js enforces strict safety with an immutable API. You cannot accidentally mutate a value.

import Dinero from 'dinero.js';

// Safe: Immutable operations
const d1 = Dinero({ amount: 10, currency: 'USD' });
const d2 = Dinero({ amount: 20, currency: 'USD' });
const total = d1.add(d2);

console.log(total.getAmount()); // 30
// d1 and d2 remain unchanged

currency-formatter does not perform math. It only formats existing numbers.

import formatter from 'currency-formatter';

// No math capabilities
const amount = 0.1 + 0.2; // You must handle math yourself
console.log(formatter.format(amount, { code: 'USD' })); // "$0.30" (if you fixed the math)

🎨 Formatting Flexibility: Strings vs. Objects

How you get the final string out of the library varies. Some return simple strings, while others return objects that you must explicitly format.

currency-formatter is dedicated to string output based on ISO codes. It handles locale specifics automatically.

import formatter from 'currency-formatter';

// Direct string output
const result = formatter.format(1234.56, { code: 'USD' });
console.log(result); // "$1,234.56"

const euro = formatter.format(1234.56, { code: 'EUR', locale: 'de-DE' });
console.log(euro); // "1.234,56 €"

numeral uses a token-based system similar to Excel or Moment.js for highly custom formats.

import numeral from 'numeral';

// Custom token formatting
const result = numeral(1234.56).format('$0,0.00');
console.log(result); // "$1,234.56"

const percent = numeral(0.85).format('0.00%');
console.log(percent); // "85.00%"

currency.js returns an object that stringifies easily but allows property access.

import currency from 'currency.js';

// Object that acts like a string
const result = currency(1234.56, { symbol: '£' });
console.log(result.format()); // "£1,234.56"
console.log(result.value); // 1234.56 (number)

dinero.js requires explicit method calls to format, offering granular control over locale and digits.

import Dinero from 'dinero.js';

// Explicit formatting methods
const d = Dinero({ amount: 123456, currency: 'USD' });
console.log(d.toFormat()); // "$1,234.56"
console.log(d.toFormat('en-GB')); // "US$1,234.56"

📦 Data Scope: Currency Only vs. General Numbers

Not every project needs currency. Sometimes you need to format file sizes, percentages, or durations.

numeral is the only general-purpose tool here. It handles bytes, time, and ordinals.

import numeral from 'numeral';

// Bytes
console.log(numeral(1024).format('0.00b')); // "1.00KB"

// Time
console.log(numeral(10000).format('00:00:00')); // "02:46:40"

// Ordinal
console.log(numeral(1).format('0o')); // "1st"

currency-formatter, currency.js, and dinero.js are strictly for monetary values. They require a currency code or symbol and will not format bytes or generic percentages effectively.

// dinero.js example - requires currency code
const d = Dinero({ amount: 500, currency: 'USD' });
// You cannot create a Dinero object without a currency

⚠️ Maintenance and Future Proofing

A critical architectural decision is the long-term viability of the library.

numeral is officially unmaintained. The repository has not seen significant updates in years. Using it in new projects introduces technical debt immediately.

// numeral
// Status: Unmaintained. Do not use for new financial projects.
import numeral from 'numeral';

dinero.js (v1) is in maintenance mode. The team has shifted focus to a complete rewrite called dinero (v2), which uses a different API. If you start with v1 today, you may face a migration path later.

// dinero.js (v1)
// Status: Maintenance mode. Successor available.
import Dinero from 'dinero.js';

currency.js and currency-formatter are actively maintained and stable for their specific scopes. They are safe bets for their respective use cases.

// currency.js
// Status: Active
import currency from 'currency.js';

🌐 Real-World Implementation Patterns

Scenario 1: E-Commerce Shopping Cart

You need to add items, apply tax, and show the total without rounding errors.

  • ✅ Best choice: currency.js or dinero.js
  • Why? You need math safety. numeral would cause pennies to disappear over many transactions.
// Using currency.js for a cart
import currency from 'currency.js';

const cart = [currency(19.99), currency(5.50)];
const subtotal = cart.reduce((acc, item) => acc.add(item), currency(0));
const tax = subtotal.multiply(0.08);
const total = subtotal.add(tax);

console.log(total.format()); // "$27.59"

Scenario 2: Read-Only Financial Report

You receive pre-calculated decimals from an API and just need to display them in multiple currencies.

  • ✅ Best choice: currency-formatter
  • Why? It's lightweight and handles ISO codes perfectly without the overhead of a math engine.
// Using currency-formatter for display
import formatter from 'currency-formatter';

const apiValue = 12345.67; // Already calculated backend
console.log(formatter.format(apiValue, { code: 'JPY' })); // "¥12,346" (handles rounding)
console.log(formatter.format(apiValue, { code: 'USD' })); // "$12,345.67"

Scenario 3: Dashboard with Mixed Metrics

You need to show revenue (currency), growth (percentage), and storage used (bytes).

  • ✅ Best choice: numeral (with caution) or a hybrid approach.
  • Why? Only numeral handles bytes and percentages natively. However, for the revenue part, you should calculate with currency.js first, then format with numeral if needed, or stick to numeral only if the precision risk is acceptable for your specific dashboard.
// Hybrid approach for safety + variety
import currency from 'currency.js';
import numeral from 'numeral';

// Calculate safely
const revenue = currency(1000000).multiply(0.15).value; 

// Format diverse types
console.log(numeral(revenue).format('$0,0')); // Revenue
console.log(numeral(0.15).format('0.00%'));   // Growth
console.log(numeral(5242880).format('0.00b')); // Storage

📊 Summary Table

Featurecurrency-formattercurrency.jsdinero.js (v1)numeral
Primary GoalDisplay CurrencyCurrency Math & FormatPrecise Financial LogicGeneral Number Format
Math SafetyN/A (No Math)✅ Integer-based✅ Integer-based❌ Floating-point
ImmutabilityN/A❌ Mutable chain✅ Immutable❌ Mutable
Data TypesCurrency OnlyCurrency OnlyCurrency OnlyCurrency, %, Bytes, Time
Maintenance✅ Active✅ Active⚠️ Maintenance Mode❌ Unmaintained
Bundle WeightLightLightMediumMedium

💡 Final Recommendation

For new financial applications, avoid numeral entirely due to precision errors and lack of maintenance. If your app involves calculations (carts, ledgers, splits), reach for currency.js for its simplicity or dinero.js if you need strict immutability and audit trails (keeping in mind the v2 migration). If you only need to display values that are already calculated safely on the backend, currency-formatter is the most efficient tool for the job. Always separate your calculation logic from your formatting logic to keep your code clean and testable.

How to Choose: numeral vs currency.js vs dinero.js vs currency-formatter

  • numeral:

    Choose numeral only for legacy projects or non-financial use cases where you need to format diverse data types like percentages, bytes, time, or ordinal numbers. Do NOT use numeral for new financial applications or currency calculations because it relies on JavaScript's native floating-point math, which leads to precision errors (e.g., 0.1 + 0.2 !== 0.3). It is also officially marked as unmaintained, so modern alternatives are preferred for any critical logic.

  • currency.js:

    Choose currency.js if you need to perform arithmetic operations (add, subtract, multiply) on currency values without encountering floating-point rounding errors. It stores values as integers internally, making it safe for financial calculations like shopping carts or invoicing. It is a good middle-ground choice when you need both reliable math and flexible formatting options without the strict immutability constraints of more complex libraries.

  • dinero.js:

    Choose dinero.js if you are building a financial application where data integrity, immutability, and auditability are critical. It forces you to handle currency amounts and codes explicitly, preventing accidental mixing of currencies or precision loss. Note that dinero.js v1 is in maintenance mode; for new projects requiring these features, you should evaluate its successor dinero (v2) or ensure v1 meets your long-term needs, as it may not receive new features.

  • currency-formatter:

    Choose currency-formatter if your only requirement is to display currency symbols and formatting based on ISO codes (like 'USD' or 'EUR') without performing any math. It is lightweight and perfect for read-only views where you already have the final number and just need it to look correct for a specific locale. Avoid this if you need to calculate totals, apply taxes, or handle sub-unit precision logic, as it does not support arithmetic operations.

Similar Npm Packages to numeral

numeral is a JavaScript library designed for formatting and manipulating numbers. It provides a simple and intuitive API for formatting numbers into various styles, such as currency, percentages, and more. This makes it a popular choice for developers who need to present numerical data in a user-friendly manner. While numeral is a robust solution for number formatting, there are several alternatives available that also cater to similar needs. Here are a few noteworthy options:

  • accounting is a lightweight JavaScript library for number formatting and manipulation, particularly focused on financial data. It provides functions for formatting currency, percentages, and numbers with thousands separators. If your application primarily deals with financial data and you need a straightforward way to format and manipulate numbers, accounting is a solid choice. Its simplicity and focus on financial use cases make it an appealing alternative to numeral.

  • d3-format is part of the D3.js library, which is widely used for data visualization. The d3-format module provides powerful formatting capabilities for numbers, including support for custom formats. If you're already using D3 for visualizations or need advanced formatting options, d3-format can be a great choice. It allows for extensive customization and is particularly useful when working with complex datasets that require specific formatting rules.

  • numbro is another library for formatting numbers, inspired by numeral.js. It offers a similar API and supports various formats, including currency, percentages, and more. numbro is designed to be lightweight and easy to use, making it a good alternative for developers looking for a straightforward number formatting solution. Its compatibility with numeral.js means that transitioning between the two libraries can be relatively seamless.

For a detailed comparison of these libraries, check out the following link: Comparing accounting vs d3-format vs numbro vs numeral.

Similar Npm Packages to currency.js

currency.js is a lightweight JavaScript library designed for handling currency calculations and formatting. It provides a simple and intuitive API for performing arithmetic operations on currency values while ensuring precision and accuracy. This makes it an excellent choice for developers working on financial applications, e-commerce platforms, or any project that requires handling monetary values. While currency.js is a robust solution for currency management, there are several alternatives available in the ecosystem. Here are a few notable ones:

  • currency-formatter is a library focused on formatting currency values for display. It allows developers to easily format numbers as currency strings based on locale and currency type. While it does not handle arithmetic operations like currency.js, it excels in providing a straightforward way to display currency values in a user-friendly format. If your primary need is to format currency for presentation rather than perform calculations, currency-formatter is a suitable choice.

  • dinero.js is a powerful library for creating and manipulating monetary values. It provides a comprehensive API for performing arithmetic operations, formatting, and handling currency conversions. Dinero.js is particularly useful for applications that require complex financial calculations, as it ensures precision and supports multiple currencies. If your project involves advanced currency management, such as handling discounts, taxes, or multi-currency transactions, dinero.js is a strong contender.

  • numeral is a library for formatting and manipulating numbers, including currency values. It provides a flexible way to format numbers as currency, percentages, and more. While it is not specifically designed for currency management like currency.js or dinero.js, it offers a versatile solution for general number formatting needs. If your application requires a broader range of number formatting capabilities beyond just currency, numeral is a good option.

To explore how these libraries compare, check out the comparison: Comparing currency-formatter vs currency.js vs dinero.js vs numeral.

Similar Npm Packages to dinero.js

dinero.js is a powerful JavaScript library designed for handling monetary values and currency calculations in a precise and reliable manner. It provides a robust API for creating, manipulating, and formatting currency values, making it an excellent choice for applications that require accurate financial computations. With features like currency conversion, rounding, and formatting, dinero.js helps developers avoid common pitfalls associated with floating-point arithmetic, ensuring that financial calculations are both accurate and easy to manage.

While dinero.js is a strong contender for handling monetary values, there are alternatives worth considering:

  • currency.js is a lightweight library that provides a simple API for currency manipulation and formatting. It focuses on basic arithmetic operations and supports various currency formats, making it easy to use for straightforward financial calculations. If your application requires basic currency handling without the need for advanced features like currency conversion or complex formatting, currency.js is a great option. Its simplicity and ease of use make it suitable for smaller projects or applications with less demanding financial requirements.

To see how dinero.js compares with currency.js, check out the comparison: Comparing currency.js vs dinero.js.

Similar Npm Packages to currency-formatter

currency-formatter is a lightweight JavaScript library designed to format currency values in a user-friendly manner. It allows developers to easily convert numbers into formatted currency strings, taking into account different currencies, locales, and formatting options. This package is particularly useful for applications that require displaying monetary values, such as e-commerce platforms or financial dashboards. While currency-formatter is a solid choice for currency formatting, there are several alternatives available that offer similar functionality. Here are a few noteworthy options:

  • accounting-js is a library that provides a set of utilities for formatting numbers, currencies, and percentages. It is highly customizable and allows developers to define their own formatting rules. accounting-js is particularly useful for applications that require more than just currency formatting, as it also supports number formatting and basic arithmetic operations. If you need a versatile library that can handle various types of number formatting, accounting-js is a great option.

  • currency.js is a library specifically designed for handling currency values in JavaScript. It provides a simple API for creating, manipulating, and formatting currency values, ensuring precision and accuracy in calculations. currency.js is particularly useful for applications that require strict handling of monetary values, as it avoids floating-point errors commonly encountered in JavaScript. If your application demands high precision in currency calculations, currency.js is an excellent choice.

  • intl is a built-in JavaScript object that provides internationalization support, including number and currency formatting. It leverages the Intl.NumberFormat API to format numbers and currencies according to the user's locale. While intl is not a standalone library, it is a powerful option for applications that need to support multiple languages and regions. If you are looking for a native solution that adheres to internationalization standards, using intl is a great way to go.

  • numeral is a library for formatting and manipulating numbers in JavaScript. It provides a simple API for formatting numbers, currencies, and percentages, making it easy to display numerical values in a user-friendly way. numeral is particularly useful for applications that require flexible number formatting options. If you need a straightforward library for number formatting without the additional complexity of currency-specific features, numeral is a solid choice.

To see how these packages compare, check out the comparison: Comparing accounting-js vs currency-formatter vs currency.js vs intl vs numeral.

README for numeral

Numeral.js

A javascript library for formatting and manipulating numbers.

Website and documentation

Travis Build Status

Master Build Status

Develop Build Status

NPM

NPM

#CDNJS

CDNJS

Contributing

Important: Please create your branch from and submit pull requests to the develop branch. All pull requests must include the appropriate tests.

  1. Fork the library

  2. Install grunt

  3. Run npm install to install dependencies

  4. Create a new branch from develop

  5. Add your tests to the files in /tests

  6. To test your tests, run grunt

  7. When all your tests are passing, run grunt dist to compile and minify all files

  8. Submit a pull request to the develop branch.

Formats

Formats now exist in their own files and act more or less as plugins. Check out the bytes format for an example of how to create one.

Locales

When naming locale files use the ISO 639-1 language codes supplemented by ISO 3166-1 country codes when necessary.

Locale translations will not be merged without unit tests.

See the english unit tests for an example.

Changelog

2.0.6

Bug fix: Multi letter currency symbols and spacing

Added: Formatting of numbers with leading zeros

New format: Basic Point

Option: Added scalePercentBy100 (default: true) option to turn on/off scaling percentages

2.0.4

Bug fix: Incorrect abbreviations for values rounded up #187

Bug fix: Signed currency is inconsistent #89

2.0.2

Bug fix: Updated module definitions

2.0.1

Bug fix: Fixed regression for webpack/browserify/rollup

2.0.0

2.0.0 brings a lot of breaking changes and a reorganization of the repo, but also simplifies the api as well as the creating of custom formats.

Breaking change / Feature: All formats are now separate files. This makes it easy to create custom formats, and will also allow for custom builds with only certain formats. (Note: The built numeral.js still contains all formats in the repo).

Breaking change / Feature: All formats and locales are now loaded using numeral.register(type, name, {})

Breaking change: All language now renamed to locale and standardized to all lowercase filenames

Breaking change: The locale function no longer loads locales, it only sets the current locale

Breaking change: The unformat function has been removed numeral().unformat(string) and now happens on numeral init numeral(string)

Breaking change / Feature: Bytes are now formatted as: b (base 1000) and ib (base 1024)

Breaking change: numeral(NaN) is now treated the same as numeral(null) and no longer throws an error

Feature: Exponential format using e+ or e-

Bug fix: Update to floating point helpers (Note: Numeral does not fix JS floating point errors, but look to our tests to see that it covers quite a few cases.)

1.5.6

Bug fix: numeral converts strings to numbers

Bug fix: Null values return same as 0

1.5.5

Contained breaking changes, recommended to use 1.5.6

Bug fix: Switch bytes back to b and change iecBinary to ib, and calculate both using 1024 for backwards compatibility

1.5.4

Contained breaking changes, recommended to use 1.5.6

Tests: Changed all tests to use Mocha and Chai

Tests: Added browser tests for Chrome, Firefox, and IE using saucelabs

Added reset function to reset numeral to default options

Added nullFormat option

Update reduce polyfill

Added Binary bytes

Bug fix: Fixes problem with many optional decimals

1.5.3

Added currency symbol to optionally appear before negative sign / open paren

Added float precision math support

Added specification of abbreviation in thousands, millions, billions

1.5.2

Bug fix: Unformat should pass through if given a number

Added a mechanism to control rounding behaviour

Added languageData() for getting and setting language props at runtime

1.5.1

Bug fix: Make sure values aren't changed during formatting

1.5.0

Add defaultFormat(). numeral().format() uses the default to format if no string is provided

.unformat() returns 0 when passed no string

Added languages.js that contains all languages

Bug fix: Fix bug while unformatting ordinals

Add format option to always show signed value

Added ability to instantiate numeral with a string value of a number

1.4.9

Bug fix: Fix bug while unformatting ordinals

1.4.8

Bug fix: Throw error if language is not defined

1.4.7

Bug fix: Fix typo for trillion

1.4.6

Bug fix: remove ' from unformatting regex that was causing an error with fr-ch.js

1.4.5

Add zeroFormat() function that accepts a string for custom formating of zeros

Add valueOf() function

Chain functionality to language function

Make all minified files have the same .min.js filename ending

1.4.1

Bug fix: Bytes not formatting correctly

1.4.0

Add optional format for all decimals

1.3.4

Remove AMD module id. (This is encouraged by require.js to make the module more portable, and keep it from creating a global)

1.3.3

AMD define() compatibility.

1.3.2

Bug fix: Formatting some numbers results in the wrong value. Issue #21

1.3.1

Bug fix: Minor fix to unformatting parser

1.3.0

Add support for spaces before/after $, a, o, b in a format string

Bug fix: Fix unformat for languages that use '.' in ordinals

Bug fix: Fix round up floating numbers with no precision correctly.

Bug fix: Fix currency signs at the end in unformat

1.2.6

Add support for optional decimal places

1.2.5

Add support for appending currency symbol

1.2.4

Add support for humanized filesizes

1.2.3

Bug Fix: Fix unformatting for languages that use '.' as thousands delimiter

1.2.2

Changed language definition property 'money' to 'currency'

1.2.1

Bug fix: Fix unformatting non-negative abbreviations

1.2.0

Add language support

Update testing for to include languages

1.1.0

Add Tests

Bug fix: Fix difference returning negative values

1.0.4

Bug fix: Non negative numbers were displaying as negative when using parentheses

1.0.3

Add ordinal formatting using 'o' in the format

1.0.2

Add clone functionality

1.0.1

Added abbreviations for thousands and millions using 'a' in the format

1.0.0

Initial release

Acknowlegements

Numeral.js, while less complex, was inspired by and heavily borrowed from Moment.js

License

Numeral.js is freely distributable under the terms of the MIT license.

Copyright (c) 2012 Adam Draper

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.