Tutorial

Before we start

Welcome to the Formik tutorial. This will teach you everything you need to know to build simple and complex forms in React.

If you're impatient and just want to start hacking on your machine locally, checkout the 60-second quickstart.

What are we building?

In this tutorial, we'll show how to build a complex newsletter signup form with React and Formik.

You can see what we'll be building here: Final Result. If the code doesn't make sense to you, don't worry! The goal of this tutorial is to help you understand Formik.

Prerequisites

You'll need to have familiarity with HTML, CSS, modern JavaScript, and React (and React Hooks) to fully understand Formik and how it works. In this tutorial, we're using arrow functions, let, const, spread syntax, destructuring, computed property names, and async/await . You can use the Babel REPL to check what ES6 code compiles to.

Setup for the Tutorial

There are two ways to complete this tutorial: you can either write the code in your browser, or you can set up a local development environment on your computer.

Setup Option 1: Write Code in the Browser

This is the quickest way to get started!

First, open this Starter Code in a new tab. The new tab should display an email address input and submit button and some React code. We will be editing the React code in this tutorial.

You can now skip the second setup option, and go to the Overview section to get an overview of Formik.

Setup Option 2: Local Development Environment

This is completely optional and not required for this tutorial!

 npx create-react-app my-app

 npm i formik

 yarn add formik

1 cd my-app
2 cd src
3 
4 # If you're using a Mac or Linux:
5 rm -f *
6 
7 # Or, if you're on Windows:
8 del *
9 
10 # Then, switch back to the project folder
11 cd ..

Help, I’m Stuck!

If you get stuck, check out Formik's GitHub Discussions. In addition, the Formium Community Discord Server is a great way to get help quickly too. If you don’t receive an answer, or if you remain stuck, please file an issue, and we’ll help you out.

Overview: What is Formik?

Formik is a small group of React components and hooks for building forms in React and React Native. It helps with the three most annoying parts:

1. Getting values in and out of form state
2. Validation and error messages
3. Handling form submission

By colocating all of the above in one place, Formik keeps things organized--making testing, refactoring, and reasoning about your forms a breeze.

The Basics

We're going to start with the most verbose way of using Formik. While this may seem a bit long-winded, it's important for you to see how Formik builds on itself so you have a full grasp of what's possible and a complete mental model of how it works.

A simple newsletter signup form

Imagine we want to add a newsletter signup form for a hypothetical blog. To start, our form will have just one field named email. With Formik, this is just a few lines of code.

1 import React from 'react';
2 import { useFormik } from 'formik';
3 
4 const SignupForm = () => {
5   // Pass the useFormik() hook initial form values and a submit function that will
6   // be called when the form is submitted
7   const formik = useFormik({
8     initialValues: {
9       email: '',
10     },
11     onSubmit: values => {
12       alert(JSON.stringify(values, null, 2));
13     },
14   });
15   return (
16     <form onSubmit={formik.handleSubmit}>
17       <label htmlFor="email">Email Address</label>
18       <input
19         id="email"
20         name="email"
21         type="email"
22         onChange={formik.handleChange}
23         value={formik.values.email}
24       />
25       <button type="submit">Submit</button>
26     </form>
27   );
28 };

We pass our form's initialValues and a submission function (onSubmit) to the useFormik() hook. The hook then returns to us a goodie bag of form state and helpers in a variable we are calling formik. In the goodie bag, there are a bunch of helper methods, but for now, the ones we care about are as follows:

• handleSubmit: A submission handler
• handleChange: A change handler to pass to each <input>, <select>, or <textarea>
• values: Our form's current values

As you can see above, we pass each of these up to their respective props...and that's it! You can now have a working form powered by Formik--instead of managing your form's values on your own and writing your own custom event handlers for every single input, you can just use useFormik().

This is pretty neat, but with just one single input, the benefits of using useFormik() are unclear. So let's add two more inputs: one for the user's first and last name, which we'll store as firstName and lastName in the form.

1 import React from 'react';
2 import { useFormik } from 'formik';
3 
4 const SignupForm = () => {
5   // Notice that we have to initialize ALL of fields with values. These
6   // could come from props, but since we don't want to prefill this form,
7   // we just use an empty string. If you don't do this, React will yell
8   // at you.
9   const formik = useFormik({
10     initialValues: {
11       firstName: '',
12       lastName: '',
13       email: '',
14     },
15     onSubmit: values => {
16       alert(JSON.stringify(values, null, 2));
17     },
18   });
19   return (
20     <form onSubmit={formik.handleSubmit}>
21       <label htmlFor="firstName">First Name</label>
22       <input
23         id="firstName"
24         name="firstName"
25         type="text"
26         onChange={formik.handleChange}
27         value={formik.values.firstName}
28       />
29       <label htmlFor="lastName">Last Name</label>
30       <input
31         id="lastName"
32         name="lastName"
33         type="text"
34         onChange={formik.handleChange}
35         value={formik.values.lastName}
36       />
37       <label htmlFor="email">Email Address</label>
38       <input
39         id="email"
40         name="email"
41         type="email"
42         onChange={formik.handleChange}
43         value={formik.values.email}
44       />
45       <button type="submit">Submit</button>
46     </form>
47   );
48 };

If you look carefully at our new code, you'll notice some patterns and symmetry forming.

1. We reuse the same exact change handler function handleChange for each HTML input.
2. We pass an id and name HTML attribute that matches the property we defined in initialValues
3. We access the field's value using the same name (email -> formik.values.email).

If you're familiar with building forms with plain React, you can think of Formik's handleChange as working like this:

1 const [values, setValues] = React.useState({});
2 
3 const handleChange = event => {
4   setValues(prevValues => ({
5     ...prevValues,
6     // we use the name to tell formik which key of `values` to update.
7     [event.target.name]: event.target.value
8   });
9 }

Validation

While our contact form works, it's not quite feature-complete. While users can submit it, it doesn't tell them which (if any) fields are required.

If we are okay with using the browser's built-in HTML input validation, you could add a required prop to each of our inputs, specify minimum/maximum lengths (maxlength and minlength), and/or add a pattern prop for regex validation for each of these inputs. These are great if you can get away with them. However, HTML validation has its limitations. First, it only works in the browser! So this clearly is not viable for React Native. Second, it's hard/impossible to show custom error messages to our user. Third, it's very janky.

As mentioned earlier, Formik keeps track of not only your form's values, but also its error messages and validation. To add validation with JS, let's specify a custom validation function and pass it as validate to the useFormik() hook. If an error exists, this custom validation function should produce an error object with a matching shape to our values/initialValues. Again...symmetry...yes...

1 import React from 'react';
2 import { useFormik } from 'formik';
3 
4 // A custom validation function. This must return an object
5 // which keys are symmetrical to our values/initialValues
6 const validate = values => {
7   const errors = {};
8   if (!values.firstName) {
9     errors.firstName = 'Required';
10   } else if (values.firstName.length > 15) {
11     errors.firstName = 'Must be 15 characters or less';
12   }
13 
14   if (!values.lastName) {
15     errors.lastName = 'Required';
16   } else if (values.lastName.length > 20) {
17     errors.lastName = 'Must be 20 characters or less';
18   }
19 
20   if (!values.email) {
21     errors.email = 'Required';
22   } else if (!/^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i.test(values.email)) {
23     errors.email = 'Invalid email address';
24   }
25 
26   return errors;
27 };
28 
29 const SignupForm = () => {
30   // Pass the useFormik() hook initial form values and a submit function that will
31   // be called when the form is submitted
32   const formik = useFormik({
33     initialValues: {
34       firstName: '',
35       lastName: '',
36       email: '',
37     },
38     validate,
39     onSubmit: values => {
40       alert(JSON.stringify(values, null, 2));
41     },
42   });
43   return (
44     <form onSubmit={formik.handleSubmit}>
45       <label htmlFor="firstName">First Name</label>
46       <input
47         id="firstName"
48         name="firstName"
49         type="text"
50         onChange={formik.handleChange}
51         value={formik.values.firstName}
52       />
53       {formik.errors.firstName ? <div>{formik.errors.firstName}</div> : null}
54       <label htmlFor="lastName">Last Name</label>
55       <input
56         id="lastName"
57         name="lastName"
58         type="text"
59         onChange={formik.handleChange}
60         value={formik.values.lastName}
61       />
62       {formik.errors.lastName ? <div>{formik.errors.lastName}</div> : null}
63       <label htmlFor="email">Email Address</label>
64       <input
65         id="email"
66         name="email"
67         type="email"
68         onChange={formik.handleChange}
69         value={formik.values.email}
70       />
71       {formik.errors.email ? <div>{formik.errors.email}</div> : null}
72       <button type="submit">Submit</button>
73     </form>
74   );
75 };

formik.errors is populated via the custom validation function. By default, Formik will validate after each keystroke (change event), each input's blur event, as well as prior to submission. It will only proceed with executing the onSubmit function we passed to useFormik() if there are no errors (i.e. if our validation function returned {}).

Visited fields

While our form works, and our users see each error, it's not a great user experience for them. Since our validation function runs on each keystroke against the entire form's values, our errors object contains all validation errors at any given moment. In our component, we are just checking if an error exists and then immediately showing it to the user. This is awkward since we're going to show error messages for fields that the user hasn't even visited yet. Most of the time, we only want to show a field's error message after our user is done typing in that field.

Like errors and values, Formik can keep track of which fields have been visited. It stores this information in an object called touched that also mirrors the shape of values/initialValues, but each key can only be a boolean true/false.

To take advantage of touched, we can pass formik.handleBlur to each input's onBlur prop. This function works similarly to formik.handleChange in that it uses the name attribute to figure out which field to update.

1 import React from 'react';
2 import { useFormik } from 'formik';
3 
4 const validate = values => {
5   const errors = {};
6   if (!values.firstName) {
7     errors.firstName = 'Required';
8   } else if (values.firstName.length > 15) {
9     errors.firstName = 'Must be 15 characters or less';
10   }
11 
12   if (!values.lastName) {
13     errors.lastName = 'Required';
14   } else if (values.lastName.length > 20) {
15     errors.lastName = 'Must be 20 characters or less';
16   }
17 
18   if (!values.email) {
19     errors.email = 'Required';
20   } else if (!/^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i.test(values.email)) {
21     errors.email = 'Invalid email address';
22   }
23 
24   return errors;
25 };
26 
27 const SignupForm = () => {
28   const formik = useFormik({
29     initialValues: {
30       firstName: '',
31       lastName: '',
32       email: '',
33     },
34     validate,
35     onSubmit: values => {
36       alert(JSON.stringify(values, null, 2));
37     },
38   });
39   return (
40     <form onSubmit={formik.handleSubmit}>
41       <label htmlFor="firstName">First Name</label>
42       <input
43         id="firstName"
44         name="firstName"
45         type="text"
46         onChange={formik.handleChange}
47         onBlur={formik.handleBlur}
48         value={formik.values.firstName}
49       />
50       {formik.errors.firstName ? <div>{formik.errors.firstName}</div> : null}
51       <label htmlFor="lastName">Last Name</label>
52       <input
53         id="lastName"
54         name="lastName"
55         type="text"
56         onChange={formik.handleChange}
57         onBlur={formik.handleBlur}
58         value={formik.values.lastName}
59       />
60       {formik.errors.lastName ? <div>{formik.errors.lastName}</div> : null}
61       <label htmlFor="email">Email Address</label>
62       <input
63         id="email"
64         name="email"
65         type="email"
66         onChange={formik.handleChange}
67         onBlur={formik.handleBlur}
68         value={formik.values.email}
69       />
70       {formik.errors.email ? <div>{formik.errors.email}</div> : null}
71       <button type="submit">Submit</button>
72     </form>
73   );
74 };

Almost there! Now that we're tracking touched, we can now change our error message render logic to only show a field's error message if it exists and if our user has visited a given field.

1 import React from 'react';
2 import { useFormik } from 'formik';
3 
4 const validate = values => {
5   const errors = {};
6   if (!values.firstName) {
7     errors.firstName = 'Required';
8   } else if (values.firstName.length > 15) {
9     errors.firstName = 'Must be 15 characters or less';
10   }
11 
12   if (!values.lastName) {
13     errors.lastName = 'Required';
14   } else if (values.lastName.length > 20) {
15     errors.lastName = 'Must be 20 characters or less';
16   }
17 
18   if (!values.email) {
19     errors.email = 'Required';
20   } else if (!/^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i.test(values.email)) {
21     errors.email = 'Invalid email address';
22   }
23 
24   return errors;
25 };
26 
27 const SignupForm = () => {
28   const formik = useFormik({
29     initialValues: {
30       firstName: '',
31       lastName: '',
32       email: '',
33     },
34     validate,
35     onSubmit: values => {
36       alert(JSON.stringify(values, null, 2));
37     },
38   });
39   return (
40     <form onSubmit={formik.handleSubmit}>
41       <label htmlFor="firstName">First Name</label>
42       <input
43         id="firstName"
44         name="firstName"
45         type="text"
46         onChange={formik.handleChange}
47         onBlur={formik.handleBlur}
48         value={formik.values.firstName}
49       />
50       {formik.touched.firstName && formik.errors.firstName ? (
51         <div>{formik.errors.firstName}</div>
52       ) : null}
53       <label htmlFor="lastName">Last Name</label>
54       <input
55         id="lastName"
56         name="lastName"
57         type="text"
58         onChange={formik.handleChange}
59         onBlur={formik.handleBlur}
60         value={formik.values.lastName}
61       />
62       {formik.touched.lastName && formik.errors.lastName ? (
63         <div>{formik.errors.lastName}</div>
64       ) : null}
65       <label htmlFor="email">Email Address</label>
66       <input
67         id="email"
68         name="email"
69         type="email"
70         onChange={formik.handleChange}
71         onBlur={formik.handleBlur}
72         value={formik.values.email}
73       />
74       {formik.touched.email && formik.errors.email ? (
75         <div>{formik.errors.email}</div>
76       ) : null}
77       <button type="submit">Submit</button>
78     </form>
79   );
80 };

Schema Validation with Yup

As you can see above, validation is left up to you. Feel free to write your own validators or use a 3rd-party helper library. Formik's authors/a large portion of its users use Jason Quense's library Yup for object schema validation. Yup has an API that's similar to Joi / React PropTypes but is also small enough for the browser and fast enough for runtime usage. You can try it out here with this REPL.

Since Formik authors/users love Yup so much, Formik has a special configuration option / prop for Yup called validationSchema which will automatically transform Yup's validation errors messages into a pretty object whose keys match values/initialValues/touched (just like any custom validation function would have to). Anyways, you can install Yup from NPM/yarn like so...

1 npm install yup --save
2 
3 # or via yarn
4 
5 yarn add yup

To see how Yup works, let's get rid of our custom validation function validate and re-write our validation with Yup and validationSchema:

1 import React from 'react';
2 import { useFormik } from 'formik';
3 import * as Yup from 'yup';
4 
5 const SignupForm = () => {
6   const formik = useFormik({
7     initialValues: {
8       firstName: '',
9       lastName: '',
10       email: '',
11     },
12     validationSchema: Yup.object({
13       firstName: Yup.string()
14         .max(15, 'Must be 15 characters or less')
15         .required('Required'),
16       lastName: Yup.string()
17         .max(20, 'Must be 20 characters or less')
18         .required('Required'),
19       email: Yup.string().email('Invalid email address').required('Required'),
20     }),
21     onSubmit: values => {
22       alert(JSON.stringify(values, null, 2));
23     },
24   });
25   return (
26     <form onSubmit={formik.handleSubmit}>
27       <label htmlFor="firstName">First Name</label>
28       <input
29         id="firstName"
30         name="firstName"
31         type="text"
32         onChange={formik.handleChange}
33         onBlur={formik.handleBlur}
34         value={formik.values.firstName}
35       />
36       {formik.touched.firstName && formik.errors.firstName ? (
37         <div>{formik.errors.firstName}</div>
38       ) : null}
39       <label htmlFor="lastName">Last Name</label>
40       <input
41         id="lastName"
42         name="lastName"
43         type="text"
44         onChange={formik.handleChange}
45         onBlur={formik.handleBlur}
46         value={formik.values.lastName}
47       />
48       {formik.touched.lastName && formik.errors.lastName ? (
49         <div>{formik.errors.lastName}</div>
50       ) : null}
51       <label htmlFor="email">Email Address</label>
52       <input
53         id="email"
54         name="email"
55         type="email"
56         onChange={formik.handleChange}
57         onBlur={formik.handleBlur}
58         value={formik.values.email}
59       />
60       {formik.touched.email && formik.errors.email ? (
61         <div>{formik.errors.email}</div>
62       ) : null}
63       <button type="submit">Submit</button>
64     </form>
65   );
66 };

Again, Yup is 100% optional. However, we suggest giving it a try. As you can see above, we expressed the exact same validation function with just 10 lines of code instead of 30. One of Formik's core design principles is to help you stay organized. Yup definitely helps a lot with this--schemas are extremely expressive, intuitive (since they mirror your values), and reusable. Whether or not you use Yup, it is highly recommended that you share commonly used validation methods across your application. This will ensure that common fields (e.g. email, street addresses, usernames, phone numbers, etc.) are validated consistently and result in a better user experience.

Reducing Boilerplate

getFieldProps()

The code above is very explicit about exactly what Formik is doing. onChange -> handleChange, onBlur -> handleBlur, and so on. However, to save you time, useFormik() returns a helper method called formik.getFieldProps() to make it faster to wire up inputs. Given some field-level info, it returns to you the exact group of onChange, onBlur, value, checked for a given field. You can then spread that on an input, select, or textarea.

1 import React from 'react';
2 import { useFormik } from 'formik';
3 import * as Yup from 'yup';
4 
5 const SignupForm = () => {
6   const formik = useFormik({
7     initialValues: {
8       firstName: '',
9       lastName: '',
10       email: '',
11     },
12     validationSchema: Yup.object({
13       firstName: Yup.string()
14         .max(15, 'Must be 15 characters or less')
15         .required('Required'),
16       lastName: Yup.string()
17         .max(20, 'Must be 20 characters or less')
18         .required('Required'),
19       email: Yup.string().email('Invalid email address').required('Required'),
20     }),
21     onSubmit: values => {
22       alert(JSON.stringify(values, null, 2));
23     },
24   });
25   return (
26     <form onSubmit={formik.handleSubmit}>
27       <label htmlFor="firstName">First Name</label>
28       <input
29         id="firstName"
30         type="text"
31         {...formik.getFieldProps('firstName')}
32       />
33       {formik.touched.firstName && formik.errors.firstName ? (
34         <div>{formik.errors.firstName}</div>
35       ) : null}
36       <label htmlFor="lastName">Last Name</label>
37       <input id="lastName" type="text" {...formik.getFieldProps('lastName')} />
38       {formik.touched.lastName && formik.errors.lastName ? (
39         <div>{formik.errors.lastName}</div>
40       ) : null}
41       <label htmlFor="email">Email Address</label>
42       <input id="email" type="email" {...formik.getFieldProps('email')} />
43       {formik.touched.email && formik.errors.email ? (
44         <div>{formik.errors.email}</div>
45       ) : null}
46       <button type="submit">Submit</button>
47     </form>
48   );
49 };

Leveraging React Context

Our code above is again very explicit about exactly what Formik is doing. onChange -> handleChange, onBlur -> handleBlur, and so on. However, we still have to manually pass each input this "prop getter" getFieldProps(). To save you even more time, Formik comes with React Context-powered API/component make life easier and less verbose: <Formik />, <Form />, <Field />, and <ErrorMessage />. More explicitly, they use React Context implicitly to connect to the parent <Formik /> state/methods.

Since these components use React Context, we need to render a React Context Provider that holds our form state and helpers in our tree. If you did this yourself, it would look like:

1 import React from 'react';
2 import { useFormik } from 'formik';
3 
4 // Create empty context
5 const FormikContext = React.createContext({});
6 
7 // Place all of what's returned by useFormik onto context
8 export const Formik = ({ children, ...props }) => {
9   const formikStateAndHelpers = useFormik(props);
10   return (
11     <FormikContext.Provider value={formikStateAndHelpers}>
12       {typeof children === 'function'
13         ? children(formikStateAndHelpers)
14         : children}
15     </FormikContext.Provider>
16   );
17 };

Luckily, we've done this for you and a <Formik> component that works just like this one comes with the package.

Let's now swap out the useFormik() hook for the Formik's <Formik> component/render-prop. Since it's a component, we'll convert the object passed to useFormik() to JSX, with each key becoming a prop.

1 import React from 'react';
2 import { Formik } from 'formik';
3 import * as Yup from 'yup';
4 
5 const SignupForm = () => {
6   return (
7     <Formik
8       initialValues={{ firstName: '', lastName: '', email: '' }}
9       validationSchema={Yup.object({
10         firstName: Yup.string()
11           .max(15, 'Must be 15 characters or less')
12           .required('Required'),
13         lastName: Yup.string()
14           .max(20, 'Must be 20 characters or less')
15           .required('Required'),
16         email: Yup.string().email('Invalid email address').required('Required'),
17       })}
18       onSubmit={(values, { setSubmitting }) => {
19         setTimeout(() => {
20           alert(JSON.stringify(values, null, 2));
21           setSubmitting(false);
22         }, 400);
23       }}
24     >
25       {formik => (
26         <form onSubmit={formik.handleSubmit}>
27           <label htmlFor="firstName">First Name</label>
28           <input
29             id="firstName"
30             type="text"
31             {...formik.getFieldProps('firstName')}
32           />
33           {formik.touched.firstName && formik.errors.firstName ? (
34             <div>{formik.errors.firstName}</div>
35           ) : null}
36           <label htmlFor="lastName">Last Name</label>
37           <input
38             id="lastName"
39             type="text"
40             {...formik.getFieldProps('lastName')}
41           />
42           {formik.touched.lastName && formik.errors.lastName ? (
43             <div>{formik.errors.lastName}</div>
44           ) : null}
45           <label htmlFor="email">Email Address</label>
46           <input id="email" type="email" {...formik.getFieldProps('email')} />
47           {formik.touched.email && formik.errors.email ? (
48             <div>{formik.errors.email}</div>
49           ) : null}
50           <button type="submit">Submit</button>
51         </form>
52       )}
53     </Formik>
54   );
55 };

As you can see above, we swapped out useFormik() hook and replaced it with the <Formik> component. The <Formik> accepts a function as its children (a.k.a. a render prop). Its argument is the exact same object returned by useFormik() (in fact, <Formik> calls useFormik() internally!!). Thus, our form works the same as before, except now we can use new components to express ourselves in a more concise manner.

1 import React from 'react';
2 import { Formik, Field, Form, ErrorMessage } from 'formik';
3 import * as Yup from 'yup';
4 
5 const SignupForm = () => {
6   return (
7     <Formik
8       initialValues={{ firstName: '', lastName: '', email: '' }}
9       validationSchema={Yup.object({
10         firstName: Yup.string()
11           .max(15, 'Must be 15 characters or less')
12           .required('Required'),
13         lastName: Yup.string()
14           .max(20, 'Must be 20 characters or less')
15           .required('Required'),
16         email: Yup.string().email('Invalid email address').required('Required'),
17       })}
18       onSubmit={(values, { setSubmitting }) => {
19         setTimeout(() => {
20           alert(JSON.stringify(values, null, 2));
21           setSubmitting(false);
22         }, 400);
23       }}
24     >
25       <Form>
26         <label htmlFor="firstName">First Name</label>
27         <Field name="firstName" type="text" />
28         <ErrorMessage name="firstName" />
29         <label htmlFor="lastName">Last Name</label>
30         <Field name="lastName" type="text" />
31         <ErrorMessage name="lastName" />
32         <label htmlFor="email">Email Address</label>
33         <Field name="email" type="email" />
34         <ErrorMessage name="email" />
35         <button type="submit">Submit</button>
36       </Form>
37     </Formik>
38   );
39 };

The <Field> component by default will render an <input> component that given a name prop will implicitly grab the respective onChange, onBlur, value props and pass them to the element as well as any props you pass to it. However, since not everything is an input, <Field> also accepts a few other props to let you render whatever you want. Some examples..

1 // <input className="form-input" placeHolder="Jane"  />
2 <Field name="firstName" className="form-input" placeholder="Jane" />
3 
4 // <textarea className="form-textarea"/></textarea>
5 <Field name="message" as="textarea"  className="form-textarea"/>
6 
7 // <select className="my-select"/>
8 <Field name="colors" as="select" className="my-select">
9   <option value="red">Red</option>
10   <option value="green">Green</option>
11   <option value="blue">Blue</option>
12 </Field>

React is all about composition, and while we've cut down on a lot of the prop-drilling, we are still repeating ourselves with a label, <Field>, and <ErrorMessage> for each of our inputs. We can do better with an abstraction! With Formik, you can and should build reusable input primitive components that you can share around your application. Turns out our <Field> render-prop component has a sister and her name is useField that's going to do the same thing, but via React Hooks! Check this out...

1 import React from 'react';
2 import ReactDOM from 'react-dom';
3 import { Formik, Form, useField } from 'formik';
4 import * as Yup from 'yup';
5 
6 const MyTextInput = ({ label, ...props }) => {
7   // useField() returns [formik.getFieldProps(), formik.getFieldMeta()]
8   // which we can spread on <input>. We can use field meta to show an error
9   // message if the field is invalid and it has been touched (i.e. visited)
10   const [field, meta] = useField(props);
11   return (
12     <>
13       <label htmlFor={props.id || props.name}>{label}</label>
14       <input className="text-input" {...field} {...props} />
15       {meta.touched && meta.error ? (
16         <div className="error">{meta.error}</div>
17       ) : null}
18     </>
19   );
20 };
21 
22 const MyCheckbox = ({ children, ...props }) => {
23   // React treats radios and checkbox inputs differently other input types, select, and textarea.
24   // Formik does this too! When you specify `type` to useField(), it will
25   // return the correct bag of props for you
26   const [field, meta] = useField({ ...props, type: 'checkbox' });
27   return (
28     <div>
29       <label className="checkbox">
30         <input type="checkbox" {...field} {...props} />
31         {children}
32       </label>
33       {meta.touched && meta.error ? (
34         <div className="error">{meta.error}</div>
35       ) : null}
36     </dov>
37   );
38 };
39 
40 const MySelect = ({ label, ...props }) => {
41   const [field, meta] = useField(props);
42   return (
43     <div>
44       <label htmlFor={props.id || props.name}>{label}</label>
45       <select {...field} {...props} />
46       {meta.touched && meta.error ? (
47         <div className="error">{meta.error}</div>
48       ) : null}
49     </div>
50   );
51 };
52 
53 // And now we can use these
54 const SignupForm = () => {
55   return (
56     <>
57       <h1>Subscribe!</h1>
58       <Formik
59         initialValues={{
60           firstName: '',
61           lastName: '',
62           email: '',
63           acceptedTerms: false, // added for our checkbox
64           jobType: '', // added for our select
65         }}
66         validationSchema={Yup.object({
67           firstName: Yup.string()
68             .max(15, 'Must be 15 characters or less')
69             .required('Required'),
70           lastName: Yup.string()
71             .max(20, 'Must be 20 characters or less')
72             .required('Required'),
73           email: Yup.string()
74             .email('Invalid email address')
75             .required('Required'),
76           acceptedTerms: Yup.boolean()
77             .required('Required')
78             .oneOf([true], 'You must accept the terms and conditions.'),
79           jobType: Yup.string()
80             .oneOf(
81               ['designer', 'development', 'product', 'other'],
82               'Invalid Job Type'
83             )
84             .required('Required'),
85         })}
86         onSubmit={(values, { setSubmitting }) => {
87           setTimeout(() => {
88             alert(JSON.stringify(values, null, 2));
89             setSubmitting(false);
90           }, 400);
91         }}
92       >
93         <Form>
94           <MyTextInput
95             label="First Name"
96             name="firstName"
97             type="text"
98             placeholder="Jane"
99           />
100           <MyTextInput
101             label="Last Name"
102             name="lastName"
103             type="text"
104             placeholder="Doe"
105           />
106           <MyTextInput
107             label="Email Address"
108             name="email"
109             type="email"
110             placeholder="jane@formik.com"
111           />
112           <MySelect label="Job Type" name="jobType">
113             <option value="">Select a job type</option>
114             <option value="designer">Designer</option>
115             <option value="development">Developer</option>
116             <option value="product">Product Manager</option>
117             <option value="other">Other</option>
118           </MySelect>
119           <MyCheckbox name="acceptedTerms">
120             I accept the terms and conditions
121           </MyCheckbox>
122 
123           <button type="submit">Submit</button>
124         </Form>
125       </Formik>
126     </>
127   );
128 };

As you can see above, useField() gives us the ability to connect any kind input of React component to Formik as if it were a <Field> + <ErrorMessage>. We can use it to build a group of reusable inputs that fit our needs.

Wrapping Up

Congratulations! You've created a signup form with Formik that:

• Has complex validation logic and rich error messages
• Properly displays errors messages to the user at the correct time (after they have blurred a field)
• Leverages your own custom input components you can use on other forms in your app

Nice work! We hope you now feel like you have a decent grasp on how Formik works.

Check out the final result here: Final Result.

If you have extra time or want to practice your new Formik skills, here are some ideas for improvements that you could make to the signup form which are listed in order of increasing difficulty:

• Disable the submit button while the user has attempted to submit (hint: formik.isSubmitting)
• Add a reset button with formik.handleReset or <button type="reset">.
• Prepopulate initialValues based on URL query string or props passed to <SignupForm>.
• Change input border color to red when a field has an error and isn't focused
• Add a shake animation to each field when it displays an error and has been visited
• Persist form state to the browser's sessionStorage so that form progress is kept inbetween page refreshes

Throughout this tutorial, we touched on Formik concepts including form state, fields, validation, hooks, render props, and React context. For a more detailed explanation of each of these topics, check out the rest of the documentation. To learn more about defining the components and hooks in the tutorial, check out the API reference.