# How to record good typing patterns

Recording qualitative typing patterns is the basis for effective authentication with typing biometrics as a passive second factor

However, common pitfalls can easily lead you to record patterns that will result in low matching scores and higher False Rejection Rates (the metric that shows how often the system fails to identify an authorized user).

The good news is that all of these mistakes can be avoided by recording typing patterns correctly. To do that, you simply need to avoid the following all-too-common pitfalls:

- When recording **same text patterns** (type = 1), make sure you get typing patterns on the same textid (a unique identifier of the text), i.e., on the text-to-type and not the actual text being typed. You can achieve this by sending the text-to-type to the text param. If text is not provided, the recorder will generate its own textid based on the actual typed text. However, consider the case when users are asked to type the same sentence multiple times. How many of them will manage to type without typos so that you get consistent patterns on the same textid? To allow users to type naturally, you need to accept some typos. To do that, get the pattern on the textid of the same text:

```javascript
                var tdna = new TypingDNA();
                var textToType = 'This is my text to type';
                var tp = tdna.getTypingPattern({ type: 1, text: textToType });
```

That brings us to a second suggestion, when recording same text patterns: allow typos, but make sure at least 93% of the typed text matches the type-to-text:

```javascript
                var textToType = 'This is my text to type';
                var typedText = document.getElementById('inputText').value;
                var isValid = true;
                /** at least 80% of the length of the text should be typed */
                if (typedText.length / textToType.length < 0.8) {
                    isValid = false;
                }
                /** at least 80% of the words should be typed correctly */
                if (compareTexts(textToType, typedText) < 0.8) {
                    isValid = false;
                }
```

```javascript
                function compareTexts(t1, t2) {
                    var dt1 = t1.split(' ');
                    var dt2 = t2.split(' ');
                    var total2 = 0;
                    var total1 = 0;
                    for (var i in dt2) {
                        total2 += (dt1.indexOf(dt2[i]) > -1) ? 1 : 0;
                    }
                    for (var i in dt1) {
                        total1 += (dt2.indexOf(dt1[i]) > -1) ? 1 : 0;
                    }
                    var total = (dt1.length > dt2.length) ? dt1.length : dt2.length;
                    var length = (dt1.length > dt2.length) ? dt1.length : dt2.length;
                    return total / length;
                }
```

- Check for **null** typing patterns before sending them to the Authentication API service — either for enrollment or verification. This can be done easily:

```javascript
                var textToType = 'This is my text to type';
                var tp = tdna.getTypingPattern({ type: 1, text: textToType });
                var isValid = true;
                if (!tp) {
                    isValid = false;
                }
```

- If you want to record **multiple typing patterns** in the same view, the property targetId of the method getTypingPattern will come to the rescue, letting the recorder know where to collect keystrokes from. You might want to do this if you wish to perform the enrollment step in one view, collecting two or more patterns of the same text.

```javascript
                var textToType = 'This is my text to type';
                var tp1 = tdna.getTypingPattern({ type: 1, text: textToType, targetId: 'inputText1' });
                var tp2 = tdna.getTypingPattern({ type: 1, text: textToType, targetId: 'inputText2' });
```

- You may want to record one typing pattern from **multiple inputs**, e.g., getting the pattern for the username and password. In this case, the text-to-type will be the concatenated string between the typed username and the typed password. Notice that, in this use case, typos are not allowed. Otherwise, the user couldn’t log in. As such, registering the pattern on the typed text will always get the same textid.

```javascript
                var username = document.getElementById('username').value;
                var password = document.getElementById('password').value;
                var tp = tdna.getTypingPattern({ type: 1, text: username + password });
```

- A suboptimal **text length** of the typed text can negatively influence the verification score. Our recommendation is the following:
  - Same text solution: tweet-long texts of 30 characters
  - Any text solution: 160 to 200 characters for enrollment; 120 to 140 for verification

Read more about the recommended [Rules to create texts](https://api.typingdna.com/docs/#api-guidelines-faq).

- Consider that **mobile** typing patterns are different from **desktop** patterns. They capture data differently, so matching between mobile and desktop patterns will not work correctly. However, they are recorded in the same manner, so nothing needs to be done on the front-end in this case. Learn more about how to handle mobile vs. desktop patterns in this [article](https://api.typingdna.com/docs/#api-guidelines-faq-mobile).
- If you would like to record patterns on secret text, like **passwords**, we don’t recommend you get patterns of type 2, as it records the typed characters as well. Use type 1 (same text) or type 0 (any text) instead, depending on your use case. Learn more about the different types [here](https://api.typingdna.com/docs/#api-overview-sametext).
- Last but not least, don’t forget to **instantiate** the JavaScript recorder before performing any operation. Once this is done, usually when loading the page, any typing starts being recorded as a history of keystroke events.

```javascript
                var tdna = new TypingDNA();
```

For more support, contact us at [support@typingdna.com](mailto:support@typingdna.com).