<input type="text" mask="<here goes your mask>" /><input type="text" [mask]="<here goes a reference to your component's mask property>" />Also, you can use mask pipe.
<span>{{phone | mask: '(000) 000-0000'}}</span>You could path any valid config options, for example thousandSeparator and suffix
<span>{{value | mask: 'separator': { thousandSeparator: ',', suffix: ' sm' } }}</span>| mask | example |
|---|---|
| 9999-99-99 | 2017-04-15 |
| 0*.00 | 2017.22 |
| 000.000.000-99 | 048.457.987-98 |
| AAAA | 0F6g |
| SSSS | asDF |
| UUUU | ASDF |
| LLLL | asdf |
ngx-mask ships as a standalone directive (NgxMaskDirective) and pipe (NgxMaskPipe). There is no NgxMaskModule in current versions — NgxMaskModule.forRoot() only exists in ngx-mask 14.x and older. Whatever your app structure, you always import the directive/pipe directly and register the configuration through a provider function.
Which provider function should I use?
provideEnvironmentNgxMask(config?)— application-wide configuration. Use it once inbootstrapApplication/app.config.ts(or in a rootNgModule'sproviders). It returnsEnvironmentProviders, so Angular prevents you from accidentally registering it at the component level.provideNgxMask(config?)— injector-level configuration. Use it in a component's (or route's/featureNgModule's)providersto configure or override the mask options for that subtree only.
Both accept the same NgxMaskOptions object (or a factory function returning one). The options you pass are merged over the library defaults — so if a component provides provideNgxMask(), the resulting config replaces the environment config for that subtree (options set only at the environment level are not inherited). Individual directive inputs (e.g. [thousandSeparator]) always win over any provider config.
// app.config.ts
import { provideEnvironmentNgxMask } from 'ngx-mask';
export const appConfig: ApplicationConfig = {
providers: [provideEnvironmentNgxMask({ validation: false })],
};// any component that uses the mask
import { NgxMaskDirective } from 'ngx-mask';
@Component({
imports: [NgxMaskDirective],
template: `<input mask="0000" />`,
})
export class MyComponent {}import { NgxMaskDirective, provideNgxMask } from 'ngx-mask';
@Component({
imports: [NgxMaskDirective],
providers: [provideNgxMask({ thousandSeparator: ',' })],
template: `<input mask="separator.2" />`,
})
export class PriceInputComponent {}Module-based apps are still supported — import the standalone directive/pipe into the imports of your NgModule and register the provider function:
import { NgxMaskDirective, NgxMaskPipe, provideEnvironmentNgxMask } from 'ngx-mask';
@NgModule({
imports: [NgxMaskDirective, NgxMaskPipe],
exports: [NgxMaskDirective, NgxMaskPipe],
providers: [provideEnvironmentNgxMask()],
})
export class AppModule {}Migrating from ngx-mask ≤ 14:
// Before (ngx-mask <= 14)
@NgModule({ imports: [NgxMaskModule.forRoot(maskConfig)] })
export class AppModule {}
// After (current ngx-mask)
@NgModule({
imports: [NgxMaskDirective],
providers: [provideEnvironmentNgxMask(maskConfig)],
})
export class AppModule {}The mask pipe reads the same provider config; per-usage overrides are passed as the pipe's second argument:
<span>{{ value | mask: 'separator' : { thousandSeparator: ',', suffix: ' sm' } }}</span>NullInjectorError: No provider for InjectionToken ngx-mask config— the directive/pipe is used without any provider in scope. AddprovideEnvironmentNgxMask()to your bootstrap providers (orprovideNgxMask()to the component).NgxMaskModulenot found — you are reading instructions for ngx-mask ≤ 14. Use the standalone imports + provider functions shown above.- Config seems ignored — a closer
provideNgxMask()in a parent component replaces the environment config for that subtree, and directive inputs override both.
You can define your custom options for all directives (as object in the mask module) or for each (as attributes for directive). If you override this parameter, you have to provide all the special characters (default one are not included).
We have next default characters:
| character |
|---|
| - |
| / |
| ( |
| ) |
| . |
| : |
| space |
| + |
| , |
| @ |
| [ |
| ] |
| " |
| ' |
<input type="text" [specialCharacters]="[ '[' ,']' , '\\' ]" mask="[00]\[000]" />Input value: 789-874.98
Masked value: [78]\[987]
patterns ({ [character: string]: { pattern: RegExp, optional?: boolean})We have next default patterns:
| code | meaning |
|---|---|
| 0 | digits (like 0 to 9 numbers) |
| 9 | digits (like 0 to 9 numbers), but optional |
| A | letters (uppercase or lowercase) and digits |
| S | only letters (uppercase or lowercase) |
| U | only letters uppercase |
| L | only letters lowercase |
<input type="text" [patterns]="customPatterns" mask="(000-000)" />and in your component
public customPatterns = { '0': { pattern: new RegExp('\[a-zA-Z\]')} };Input value: 789HelloWorld
Masked value: (Hel-loW)
You can define a custom pattern and specify a unique symbol to be rendered in the input field.
Important Notes:
Reserved Characters: Certain characters (h, d, m, s) are reserved for date patterns and should not be used in custom patterns to avoid conflicts.
Special Symbol *: The * character is reserved for patterns like 0*, which means any length of digits
can appear before the asterisk. Avoid using this symbol in custom patterns.
<input type="text" mask="A*" />pattern = {
B: {
pattern: new RegExp('\\d'),
symbol: 'X',
},
};You can add prefix to you masked value
<input type="text" prefix="+7" mask="(000) 000 00 00" />The input property instantPrefix controls the display behavior of a prefix in the input.
When set to true, the prefix is displayed even if the model is empty. When set to false, the prefix only becomes visible when a value is present in the model.
<input type="text" prefix="+7" instantPrefix="false" mask="(000) 000 00 00" />
<input type="text" prefix="+7" instantPrefix="true" mask="(000) 000 00 00" />You can add suffix to you masked value
<input type="text" suffix="$" mask="0000" />You can choose if mask will drop special character in the model, or not, default value is true.
<input type="text" [dropSpecialCharacters]="false" mask="000-000.00" />Input value: 789-874.98
Model value: 789-874.98
You can choose if mask is shown while typing, or not, default value is false.
<input mask="(000) 000-0000" prefix="+7" [showMaskTyped]="true" />You can choose if mask will allow the use of negative numbers. The default value is false.
<input type="text" [allowNegativeNumbers]="true" mask="separator.2" />Input value: -10,000.45
Model value: -10000.45
If the showMaskTyped parameter is enabled, this setting customizes the character used as placeholder. Default value is _.
<input mask="(000) 000-0000" prefix="+7" [showMaskTyped]="true" placeHolderCharacter="*" />You can choose clear the input if the input value not match the mask, default value is false.
Opt-in "banking" typing mode for separator masks with a fixed precision (separator.N, N > 0). When enabled, typed digits fill the value from the decimal end, ATM/calculator style: typing 5 shows 0.05, then 7 shows 0.57, then 3 shows 5.73. Backspace shifts digits back to the right (5.73 → 0.57). Pasted values and values written from the model keep the regular separator formatting. Works together with thousandSeparator, prefix/suffix, allowNegativeNumbers and separatorLimit. Default value is false.
<input type="text" mask="separator.2" [typeFromDecimals]="true" thousandSeparator="," />
<!-- typing 1 2 3 4 5 6 renders: 0.01 → 0.12 → 1.23 → 12.34 → 123.45 → 1,234.56 -->It can also be enabled application-wide via the provider config (the directive input wins when both are set):
provideNgxMask({ typeFromDecimals: true });The displayed value always carries the full precision while typing — that is inherent to the mode.
When set, the given raw value is written through the regular mask pipeline on blur whenever the control's unmasked value is empty (an empty input, a bare prefix/suffix, or the untouched showMaskTyped skeleton). The display shows the masked default, the model receives the usual output (dropSpecialCharacters / outputTransformFn applied), and the write does not mark the form dirty. Default value is null (current behavior — empty inputs stay empty).
<input type="text" mask="separator.2" defaultValueOnBlur="0" />User clears the input and blurs
Displayed value: 0
Model value: 0
With showMaskTyped the default fills the leading mask slots and the placeholder skeleton covers the rest:
<input type="text" mask="0000" [showMaskTyped]="true" defaultValueOnBlur="9" />User blurs the empty input
Displayed value: 9___
Model value: 9
It can also be set application-wide via the provider config: provideNgxMask({ defaultValueOnBlur: '0' }).
If you need conditional or computed defaults instead of a fixed value, combine inputTransformFn / outputTransformFn programmatically:
// Model side: never emit an empty value
public outputTransformFn = (value: string | number | undefined | null) => (value === '' || value == null ? 0 : value);
// View side: render empty incoming model values as '0'
public inputTransformFn = (value: unknown) => (value === '' || value == null ? '0' : (value as string | number));You can pass array of expression and custom Pattern to pipe.
<span>{{phone | mask: customMask}}</span>and in your component
customMask: [string, pattern];
pattern = {
P: {
pattern: new RegExp('\\d'),
},
};
this.customMask = ['PPP-PPP', this.pattern];You can pass into mask pattern with brackets.
<input type="text" mask="A{4}" />You can divide your input by thousands, by default will seperate with a space.
<input type="text" mask="separator" />For separate input with dots.
<input type="text" mask="separator" thousandSeparator="." />For using decimals enter . and how many decimals to the end of your input to separator mask.
<input type="text" mask="separator.2" />Input value: 1234.56
Masked value: 1 234.56
Input value: 1234,56
Masked value: 1.234,56
Input value: 1234.56
Masked value: 1,234.56
<input type="text" mask="separator.2" thousandSeparator="." />
<input type="text" mask="separator.2" thousandSeparator="," />
<input type="text" mask="separator.0" thousandSeparator="." />
<input type="text" mask="separator.0" thousandSeparator="," />For limiting decimal precision add . and the precision you want to limit too on the input. 2 is useful for currency. 0 will prevent decimals completely.
Input value: 1234,56
Masked value: 1.234,56
Input value: 1234.56
Masked value: 1,234.56
Input value: 1234,56
Masked value: 1.234
Input value: 1234.56
Masked value: 1,234
<input type="text" mask="separator.2" [leadZero]="true" />To add zeros to the model at the end
Input value: 12
Masked value: 12.00
Input value: 12.1
Masked value: 12.10
<input type="text" mask="separator.2" separatorLimit="1000" />For limiting the number of digits before the decimal point you can set separatorLimit value to 10, 100, 1000 etc.
Input value: 12345678,56
Masked value: 1.234,56
You can validate your input as 24 hour format.
<input type="text" mask="Hh:m0:s0" />You can validate your date.
<input type="text" mask="d0/M0/0000" />If the leadZeroDateTime parameter is true, skipped symbols of date or time will be replaced by 0. Default value is false.
<input type="text" mask="d0/M0/0000" [leadZeroDateTime]="true" />Input value: 422020
Masked value: 04/02/2020
<input type="text" mask="Hh:m0:s0" [leadZeroDateTime]="true" />Input value: 777
Masked value: 07:07:07
You can validate your input for percents.
<input type="text" mask="percent" suffix="%" />You can validate your formControl, default value is true.
<input type="text" mask="00 00" [validation]="true" />You can hide symbols in input field and get the actual value in formcontrol.
<input placeholder="Secure input" [hiddenInput]="true" mask="XXX/X0/0000" />Day (d) and month (M) tokens can also be concealed, e.g. to hide the day and month of a date while keeping the year visible:
<input placeholder="Secure date input" [hiddenInput]="true" mask="d0/M0/0000" /><input mask="IP" /><input mask="CPF_CNPJ" /><input mask="CPF_CNPJ_ALPHA" />You can pass into mask pattern with ||.
<input mask="000.000.000-00||00.000.000/0000-00" /><input mask="(00) 0000-0000||(00) 0 0000-0000" /><input mask="00||SS" />You can define your own named masks once in the config and reference them by name in the mask input or the mask pipe. Aliases are resolved before any other mask processing, so an alias may also expand to a || multi-mask expression.
provideNgxMask({
maskAliases: {
PHONE_BR: '(00) 00000-0000',
MY_DOC: '000-AAA||0000-AAA',
},
});<input mask="PHONE_BR" /> <input mask="MY_DOC" />Alias keys should be written in UPPER_SNAKE case. They must not shadow the built-in tokens (IP, CPF_CNPJ, CPF_CNPJ_ALPHA, ...) — such aliases are ignored with a one-time console warning and the built-in mask wins. The alias map is resolved at the DI-config level, so it is static per injector: changing it at runtime is not supported.
Security note: alias values are mask expressions evaluated by the library, at the same trust level as the mask attribute itself. Define them statically in your application code and never feed untrusted user input into maskAliases values.
<input mask="0000" (maskFilled)="maskFilled()" />