The HTML <input> element is used to create interactive controls for web-based forms in order to accept data from the user; a wide variety of types of input data and control widgets are available, depending on the device and {{Glossary("user agent")}}.
<input> typesHow an <input> works varies considerably depending on the value of its type attribute, hence the different types are covered in their own separate reference pages. If this attribute is not specified, the default type adopted is text.
The available types are as follows:
{{HTMLElement("input/button", "button")}}: A push button with no default behavior.{{HTMLElement("input/checkbox", "checkbox")}}: A check box allowing single values to be selected/deselected.{{HTMLElement("input/color", "color")}}: {{HTMLVersionInline("5")}} A control for specifying a color. A color picker's UI has no required features other than accepting simple colors as text (more info).{{HTMLElement("input/date", "date")}}: {{HTMLVersionInline("5")}} A control for entering a date (year, month, and day, with no time).{{HTMLElement("input/datetime-local", "datetime-local")}}: {{HTMLVersionInline("5")}} A control for entering a date and time, with no time zone.{{HTMLElement("input/email", "email")}}: {{HTMLVersionInline("5")}} A field for editing an e-mail address.{{HTMLElement("input/file", "file")}}: A control that lets the user select a file. Use the accept attribute to define the types of files that the control can select.{{HTMLElement("input/hidden", "hidden")}}: A control that is not displayed but whose value is submitted to the server.{{HTMLElement("input/image", "image")}}: A graphical submit button. You must use the src attribute to define the source of the image and the alt attribute to define alternative text. You can use the height and width attributes to define the size of the image in pixels.{{HTMLElement("input/month", "month")}}: {{HTMLVersionInline("5")}} A control for entering a month and year, with no time zone.{{HTMLElement("input/number", "number")}}: {{HTMLVersionInline("5")}} A control for entering a number.{{HTMLElement("input/password", "password")}}: A single-line text field whose value is obscured. Use the maxlength and minlength attributes to specify the maximum length of the value that can be entered.
{{HTMLElement("input/radio", "radio")}}: A radio button, allowing a single value to be selected out of multiple choices.{{HTMLElement("input/range", "range")}}: {{HTMLVersionInline("5")}} A control for entering a number whose exact value is not important.{{HTMLElement("input/reset", "reset")}}: A button that resets the contents of the form to default values.{{HTMLElement("input/search", "search")}}: {{HTMLVersionInline("5")}} A single-line text field for entering search strings. Line-breaks are automatically removed from the input value.{{HTMLElement("input/submit", "submit")}}: A button that submits the form.{{HTMLElement("input/tel", "tel")}}: {{HTMLVersionInline("5")}} A control for entering a telephone number.{{HTMLElement("input/text", "text")}}: A single-line text field. Line-breaks are automatically removed from the input value.{{HTMLElement("input/time", "time")}}: {{HTMLVersionInline("5")}} A control for entering a time value with no time zone.{{HTMLElement("input/url", "url")}}: {{HTMLVersionInline("5")}} A field for entering a URL.{{HTMLElement("input/week", "week")}}: {{HTMLVersionInline("5")}} A control for entering a date consisting of a week-year number and a week number with no time zone.Some input types are now obsolete:
{{HTMLElement("input/datetime", "datetime")}}: {{HTMLVersionInline("5")}} {{deprecated_inline}} {{obsolete_inline}} A control for entering a date and time (hour, minute, second, and fraction of a second) based on UTC time zone. This feature has been removed from WHATWG HTML.The <input> element is one of the most powerful and complex in all of HTML due to the sheer number of combinations of input types and attributes. Since every <input> element, regardless of type, is based on the {{domxref("HTMLInputElement")}} interface, they technically all share the exact same set of attributes. However, in reality, many attributes only function on specific input types, and some input types support very few of these attributes. In addition, some input types handle certain attributes in special ways.
Here, you'll find information about the individual attributes which are common to all <input> element types, as well as a few non-standard attributes that may be worth knowing about.
This section lists the attributes which are used by all form <input> types. Attributes that are unique to particular input types—or attributes which are common to all input types but have special behaviors when used on a given input type—are instead documented on those types' pages.
Note: This includes the global HTML attributes.
| Attribute | Description |
|---|---|
{{anch("autocomplete")}} |
A string indicating the type of autocomplete functionality, if any, to allow on the input |
{{anch("autofocus")}} |
A Boolean which, if present, makes the input take focus when the form is presented |
{{anch("disabled")}} |
A Boolean attribute which is present if the input should be disabled |
{{anch("form")}} |
The {{domxref("Element.id", "id")}} of the {{HTMLElement("form")}} of which the input is a member; if absent, the input is a member of the nearest containing form, or is not a member of a form at all |
{{anch("list")}} |
The id of a {{HTMLElement("datalist")}} element that provides a list of suggested values for the input |
{{anch("name")}} |
The input's name, to identify the input in the data submitted with the form's data |
{{anch("readonly")}} |
A Boolean attribute which, if true, indicates that the input cannot be edited |
{{anch("required")}} |
A Boolean which, if true, indicates that the input must have a value before the form can be submitted |
{{anch("tabindex")}} |
A numeric value providing guidance to the {{Glossary("user agent")}} as to the order in which controls receive focus when the user presses the Tab key |
{{anch("type")}} |
A string indicating which {{anch("Form <input> types", "input type")}} the <input> element represents |
{{anch("value")}} |
The input's current value |
A string that describes what if any type of autocomplete functionality the input should provide. A typical implementation of autocomplete simply recalls previous values entered in the same input field, but more complex forms of autocomplete can exist. For instance, a browser could integrate with a device's contacts list to autocomplete email addresses in an email input field. See {{SectionOnPage("/en-US/docs/Web/HTML/Attributes/autocomplete", "Values")}} for permitted values.
This attribute has no effect on input types that do not return numeric or text data, such as checkbox or image.
See The HTML autocomplete attribute for additional information.
A Boolean attribute which, if present, indicates that the input should automatically have focus when the page has finished loading (or when the {{HTMLElement("dialog")}} containing the element has been displayed).
Note: An element with the autofocus attribute may gain focus before the {{domxref("DOMContentLoaded")}} event is fired.
No more than one element in the document may have the autofocus attribute, and autofocus cannot be used on inputs of type hidden, because hidden inputs can't be focused.
Warning: Automatically focusing a form control can confuse visually-impaired people using screen-reading technology. When autofocus is assigned, screen-readers "teleport" their user to the form control without warning them beforehand.
A Boolean attribute which, if present, indicates that the user should not be able to interact with the input. Disabled inputs are typically rendered with a dimmer color or using some other form of indication that the field is not available for use.
Specifically, disabled inputs do not receive the {{event("click")}} event, and disabled inputs are not submitted with the form.
Note: Although not required by the specification, Firefox will by default persist the dynamic disabled state of an <input> across page loads. Use the {{htmlattrxref("autocomplete","input")}} attribute to control this feature.
A string specifying the {{HTMLElement("form")}} element with which the input is associated (that is, its form owner). This string's value, if present, must match the {{htmlattrxref("id")}} of a <form> element in the same document. If this attribute isn't specified, the <input> element is associated with the nearest containing form, if any.
The form attribute lets you place an input anywhere in the document but have it included with a form elsewhere in the document.
Note: An input can only be associated with one form.
The {{domxref("Element.id", "id")}} of a {{HTMLElement("datalist")}} element located in the same document which provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the {{htmlattrxref("type", "input")}} are not included in the suggested options.
The list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.
A string specifying a name for the input control. This name is submitted along with the control's value when the form data is submitted, as well as with the owning {{HTMLElement("form")}} element's {{domxref("HTMLFormElement.elements", "elements")}} object.
When an input element is given a name, that name becomes a property of the owning form element's {{domxref("HTMLFormElement.elements")}} property. That means if you have an input whose name is set to guest and another whose name is hat-size, the following code can be used:
let form = document.querySelector("form");
let guestName = form.elements.guest;
let hatSize = form.elements["hat-size"];
When this code has run, guestName will be the {{domxref("HTMLInputElement")}} for the guest field, and hatSize the object for the hat-size field.
Warning: You should avoid giving form elements a name that corresponds to a built-in property of the form, since you would then override the predefined property or method with this reference to the corresponding input.
The name _charset_ has a special meaning. If used as the name of an <input> element of type hidden, the input's value is automatically set by the {{Glossary("user agent")}} to the character encoding being used to submit the form.
If no name is specified, or name is empty, the input's value is not submitted with the form.
Note: For historical reasons, the name isindex is not allowed. If you really want to know why, see Naming form controls: the name attribute in the HTML specification.
A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input.
The difference between disabled and readonly is that read-only controls can still function, whereas disabled controls generally do not function as controls until they are enabled.
Note: The required attribute is not permitted on inputs with the readonly attribute specified.
Note: Only text controls can be made read-only, since for other controls (such as checkboxes and buttons) there is no useful distinction between being read-only and being disabled, so the readonly attribute does not apply.
required is a Boolean attribute which, if present, indicates that the user must specify a value for the input before the owning form can be submitted. The required attribute is supported by all input types except the following:
When an input has the required attribute, the {{cssxref(":required")}} pseudo-class also applies to it. Conversely, inputs without the required attribute (except the elements that don't support it) have the {{cssxref(":optional")}} pseudo-class applied.
Note: Because a read-only field cannot have a value, required does not have any effect on inputs with the {{htmlattrxref("readonly", "input/text")}} attribute also specified.
An optional numeric value that defines both whether or not the input should be focusable through use of the Tab key as well as whether or not the element participates in sequential focus navigation. This value also establishes the order in which the element is reached using the Tab key.
The values of tabindex have special meanings depending on sign:
tabindex indicates that the element should be focusable by the user, but not using sequential keyboard navigation. It's recommended to always use a value of -1 as using other values can be complicated.tabindex of 0 means that the element should be focusable and should be reachable by sequential keyboard navigation, but that the tab order is left up to the {{Glossary("user agent")}}, which should apply the user's platform conventions. This is usually the best value to use when you want an element to be focusable and to participate in keyboard navigation rather than trying to manage the tab order yourself.tabindex indicates the tabbing order of the element. Each time the user presses the Tab key, the element with the next sequentially higher tabindex is focused. Most platforms provide a reverse-tab feature, typically using the combination of Shift + Tab, which reverses the tabbing order.If tabindex is omitted or is not a valid integer, the user agent follows platform conventions to determine what to do.
A string specifying the type of control to render. For example, to create a checkbox, a value of checkbox is used. If omitted (or an unknown value is specified), the input type text is used, creating a plaintext input field.
Permitted values are listed in {{anch("Form <input> types")}}.
The input control's value. When specified in the HTML, this is the initial value, and from then on it can be altered or retrieved at any time using JavaScript to access the respective {{domxref("HTMLInputElement")}} object's value property. The value attribute is always optional.
Note: Unlike other input controls, checkboxes and radio buttons are only included in the submitted data if the checkbox or radio button is currently checked. If it is, then the value attribute is reported as the input's value.
For example, if a checkbox whose name is status has a value of active, and the checkbox is checked, the form data submitted will include status=active. If the checkbox isn't active, it isn't listed in the form data at all. The default value for checkboxes and radio buttons is on.
The following methods are provided by the {{domxref("HTMLInputElement")}} interface which represents <input> elements in the DOM. Also available are those methods specified by the parent interfaces, {{domxref("HTMLElement")}}, {{domxref("Element")}}, {{domxref("Node")}}, and {{domxref("EventTarget")}}.
true if the element's value passes validity checks; otherwise, returns false.<input> element, if the element's content is selectable. For elements with no selectable text content (such as a visual color picker or calendar date input), this method does nothing.selectMode parameter is available to allow controlling how the existing content is affected.You can style <input> elements using various color-related attributes in particular. One unusual one that is specific to text entry-related elements is the CSS {{cssxref("caret-color")}} property, which lets you set the color used to draw the text input caret:
<label for="textInput">Note the red caret:</label> <input id="textInput" class="custom" size="32">
input.custom {
caret-color: red;
font: 16px "Helvetica", "Arial", "sans-serif"
}
{{EmbedLiveSample('Styling_input_elements', 500, 80)}}
For more information about adding color to elements in HTML, see Applying color to HTML elements using CSS.
TL;DR: To save you time, here's the key point: don't use the {{htmlattrxref("placeholder", "input")}} attribute if you can avoid it. If you need to label an <input> element, use the {{HTMLElement("label")}} element.
There are three seemingly similar ways to associate assistive text with an <input>. However, they are actually quite different, and only one of them is always a good choice. Here we will look at each of them and learn best practices for providing the user with guidance when entering data into a form.
The {{HTMLElement("label")}} element is the only way to provide explanatory information about a form field that is always appropriate (aside from any layout concerns you have). It's never a bad idea to use a <label> to explain what should be entered into an <input> or {{HTMLElement("textarea")}}.
The {{htmlattrxref("placeholder", "input")}} attribute lets you specify a text that appears within the <input> element's content area itself when empty. It's intended to be used to show an example input, rather than an explanation or prompt, but tends to be badly misused.
Here are two inputs that take a password, each with a placeholder:
The first one uses a placeholder string MyGr8P@sswrd, demonstrating what a password might look like. And no, that's not really a great password.
The second one uses a prompt string, Enter your password as a placeholder. The first, and most obvious, problem with doing this is that as soon as the user types their first character, they no longer have a prompt explaining what that field is for.
That's why, instead, you should use the {{HTMLElement("label")}} element. The placeholder should never be required in order to understand your forms. While some people are able to remember what a given empty box is meant for after its only identifying text vanishes, others cannot.
If the user can't understand your form if the placeholders are missing (say, in a browser that doesn't support placeholder, or in the case above where the user starts typing then gets confused), you're not using placeholders properly.
In addition, browsers with automatic page translation features may skip over attributes when translating. That means the placeholder may not get translated, resulting in important information not being translated.
If you feel like you need to use a placeholder, it's possible to use both a placeholder and a label:
You can also just have plain text adjacent to the <input> element, like this:
<p>Enter your name: <input id="name" type="text" size="30"></p>
Please don't do this. This doesn't create a relationship between the prompt and the <input> element, which is important for reasons we'll get into in the next section.
In addition to the information provided above, there are a number of other reasons why <label> is the best way to explain <input>s:
<input> and <label> elements is useful for assistive technologies such as screen readers. By pairing them using the <label>'s {{htmlattrxref("for", "label")}} attribute, you bond the label to the input in a way that lets screen readers describe inputs to users more precisely.<label> with an <input>, clicking on either one will focus the <input>. If you use plaintext to "label" your input, this won't happen. Having the prompt part of the activation area for the input is helpful for people with motor control conditions.You can find multiple examples of <input> element usage on the pages covering each individual type — see {{anch("Form <input> types")}}, and also see the {{anch("Live example")}} at the top of the article.
| Content categories | Flow content, listed, submittable, resettable, form-associated element, phrasing content. If the {{htmlattrxref("type", "input")}} is not hidden, then labelable element, palpable content. |
|---|---|
| Permitted content | None, it is an {{Glossary("empty element")}}. |
| Tag omission | Must have a start tag and must not have an end tag. |
| Permitted parents | Any element that accepts phrasing content. |
| Permitted ARIA roles |
|
| DOM interface | {{domxref("HTMLInputElement")}} |
| Specification | Status | Comment |
|---|---|---|
| {{SpecName('HTML WHATWG', 'forms.html#the-input-element', '<input>')}} | {{Spec2('HTML WHATWG')}} | |
| {{SpecName('HTML Media Capture', '#the-capture-attribute','<input capture>')}} | {{Spec2('HTML Media Capture')}} | Adds the capture attribute |
| {{SpecName('HTML5 W3C', 'forms.html#the-input-element', '<input>')}} | {{Spec2('HTML5 W3C')}} | |
| {{SpecName('HTML4.01', 'interact/forms.html#h-17.4', '<form>')}} | {{Spec2('HTML4.01')}} |
When including inputs, it is recommended to add labels along side. This is so those who use assistive technologies can tell what the input is for. For more information about labels in general see {{anch("Labels and placeholders")}} .
The following is an example of how to associate the <label> with an <input> element in the above style. You need to give the <input> an id attribute. The <label> then needs a for attribute whose value is the same as the input's id.
<label for="peas">Do you like peas?</label> <input type="checkbox" name="peas" id="peas">
Interactive elements such as form input should provide an area large enough that it is easy to activate them. This helps a variety of people, including people with motor control issues and people using non-precise forms of input such as a stylus or fingers. A minimum interactive size of 44 by 44 CSS pixels is recommended.
[1] It is recognized but there is no UI.
[2] Missing for type="checkbox" and type="radio".
[3] In Safari autocapitalize="words" capitalizes every word's second character.
[4] datetime has been removed from the spec and browsers in favour of datetime-local.
[5] see {{bug(1355389)}}
[6] Not yet implemented. For progress, see {{bug("888320")}} and TPE DOM/Date time input types.
If you want to present a custom error message when a field fails to validate, you need to use the Constraint validation features available on <input> (and related) elements. Take the following form:
<form> <label for="name">Enter username (upper and lowercase letters): </label> <input type="text" name="name" id="name" required pattern="[A-Za-z]+"> <button>Submit</button> </form>
The basic HTML form validation features will cause this to produce a default error message if you try to submit the form with either no valid filled in, or a value that does not match the pattern.
If you wanted to instead display custom error messages, you could use JavaScript like the following:
const nameInput = document.querySelector('input');
const form = document.querySelector('form');
nameInput.addEventListener('input', () => {
nameInput.setCustomValidity('');
nameInput.checkValidity();
});
nameInput.addEventListener('invalid', () => {
if(nameInput.value === '') {
nameInput.setCustomValidity('Enter your username!');
} else {
nameInput.setCustomValidity('Usernames can only contain upper and lowercase letters. Try again!');
}
});
The example renders like so:
{{EmbedLiveSample('Custom_error_messages')}}
In brief:
checkValidity() method via the input event handler.invalid event is raised, and the invalid event handler function is run. Inside this function we work out whether the value is invalid because it is empty, or because it doesn't match the pattern, using an if() block, and set a custom validity error message.setCustomValidity() with an empty string value. We therefore do this every time the input event is raised. If you don't do this, and a custom validity was previously set, the input will register as invalid, even if it current contains a valid value on submission.Note: Firefox supported a proprietary error attribute — x-moz-errormessage — for many versions, which allowed you set custom error messages in a similar way. This has been removed as of version 66 (see {{bug(1513890)}}).
The allowed inputs for certain <input> types depend on the locale. In some locales, 1,000.00 is a valid number, while in other locales the valid way to enter this number is 1.000,00.
Firefox uses the following heuristics to determine the locale to validate the user's input (at least for type="number"):
lang/xml:lang attribute on the element or any of its parents.You can use the {{htmlattrxref("mozactionhint", "input")}} attribute to specify the text for the label of the enter key on the virtual keyboard when your form is rendered on Firefox mobile. For example, to have a "Next" label, you can do this:
<input type="text" mozactionhint="next">
The result is:
Note the "Next" key in the lower-right corner of the keyboard.
<input> element is a replaced element. When it is, the position and size of the element's size and positioning within its frame can be adjusted using the CSS {{cssxref("object-position")}} and {{cssxref("object-fit")}} properties