## With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

No credit card required

# 4.13. Validate ISBNs

## Problem

You need to check the validity of an International Standard Book Number (ISBN), which can be in either the older ISBN-10 or the current ISBN-13 format. You want to allow a leading “ISBN” identifier, and ISBN parts can optionally be separated by hyphens or spaces. All of the following are examples of valid input:

• ```ISBN 978-0-596-52068-7```

• ```ISBN-13: 978-0-596-52068-7```

• ```978 0 596 52068 7```

• `9780596520687`

• ```ISBN-10 0-596-52068-9```

• `0-596-52068-9`

## Solution

You cannot validate an ISBN using a regex alone, because the last digit is computed using a checksum algorithm. The regular expressions in this section validate the format of an ISBN, whereas the subsequent code examples include a validity check for the final digit.

### Regular expressions

Three regex solutions follow that allow you to match ISBN-10s and ISBN-13s, either exclusively or together. Each of the solutions is shown with and without free-spacing and comments. JavaScript doesn’t support free-spacing, but with other programming languages you can choose whichever suits you best.

In the free-spaced regexes, literal space characters have been escaped with backslashes. Java’s free-spacing mode requires that even spaces within character classes be escaped.

ISBN-10:

```^(?:ISBN(?:-10)?:?●)?(?=[0-9X]{10}\$|(?=(?:[0-9]+[-●]){3})[-●0-9X]{13}\$)↵
[0-9]{1,5}[-●]?[0-9]+[-●]?[0-9]+[-●]?[0-9X]\$```
 Regex options: None Regex flavors: .NET, Java, JavaScript, PCRE, Perl, Python, Ruby
```^
(?:ISBN(?:-10)?:?\ )?     # Optional ISBN/ISBN-10 identifier.
(?=                       # Basic format pre-checks (lookahead):
[0-9X]{10}\$             #   Require 10 digits/Xs (no separators).
|                        #  Or:
(?=(?:[0-9]+[-\ ]){3})  #   Require 3 separators
[-\ 0-9X]{13}\$          #     out of 13 characters total.
)                         # End format pre-checks.
[0-9]{1,5}[-\ ]?          # 1-5 digit group identifier.
[0-9]+[-\ ]?[0-9]+[-\ ]?  # Publisher and title identifiers.
[0-9X]                    # Check digit.
\$```
 Regex options: Free-spacing Regex flavors: .NET, Java, XRegExp, PCRE, Perl, Python, Ruby

ISBN-13:

```^(?:ISBN(?:-13)?:?●)?(?=[0-9]{13}\$|(?=(?:[0-9]+[-●]){4})[-●0-9]{17}\$)↵
97[89][-●]?[0-9]{1,5}[-●]?[0-9]+[-●]?[0-9]+[-●]?[0-9]\$```
 Regex options: None Regex flavors: .NET, Java, JavaScript, PCRE, Perl, Python, Ruby
```^
(?:ISBN(?:-13)?:?\ )?     # Optional ISBN/ISBN-13 identifier.
(?=                       # Basic format pre-checks (lookahead):
[0-9]{13}\$              #   Require 13 digits (no separators).
|                        #  Or:
(?=(?:[0-9]+[-\ ]){4})  #   Require 4 separators
[-\ 0-9]{17}\$           #     out of 17 characters total.
)                         # End format pre-checks.
97[89][-\ ]?              # ISBN-13 prefix.
[0-9]{1,5}[-\ ]?          # 1-5 digit group identifier.
[0-9]+[-\ ]?[0-9]+[-\ ]?  # Publisher and title identifiers.
[0-9]                     # Check digit.
\$```
 Regex options: Free-spacing Regex flavors: .NET, Java, XRegExp, PCRE, Perl, Python, Ruby

ISBN-10 or ISBN-13:

```^(?:ISBN(?:-1[03])?:?●)?(?=[0-9X]{10}\$|(?=(?:[0-9]+[-●]){3})↵
[-●0-9X]{13}\$|97[89][0-9]{10}\$|(?=(?:[0-9]+[-●]){4})[-●0-9]{17}\$)↵
(?:97[89][-●]?)?[0-9]{1,5}[-●]?[0-9]+[-●]?[0-9]+[-●]?[0-9X]\$```
 Regex options: None Regex flavors: .NET, Java, JavaScript, PCRE, Perl, Python, Ruby
```^
(?:ISBN(?:-1[03])?:?\ )?  # Optional ISBN/ISBN-10/ISBN-13 identifier.
(?=                       # Basic format pre-checks (lookahead):
[0-9X]{10}\$             #   Require 10 digits/Xs (no separators).
|                        #  Or:
(?=(?:[0-9]+[-\ ]){3})  #   Require 3 separators
[-\ 0-9X]{13}\$          #     out of 13 characters total.
|                        #  Or:
97[89][0-9]{10}\$        #   978/979 plus 10 digits (13 total).
|                        #  Or:
(?=(?:[0-9]+[-\ ]){4})  #   Require 4 separators
[-\ 0-9]{17}\$           #     out of 17 characters total.
)                         # End format pre-checks.
(?:97[89][-\ ]?)?         # Optional ISBN-13 prefix.
[0-9]{1,5}[-\ ]?          # 1-5 digit group identifier.
[0-9]+[-\ ]?[0-9]+[-\ ]?  # Publisher and title identifiers.
[0-9X]                    # Check digit.
\$```
 Regex options: Free-spacing Regex flavors: .NET, Java, XRegExp, PCRE, Perl, Python, Ruby

### JavaScript example, with checksum validation

```var subject = document.getElementById("isbn").value;

// Checks for ISBN-10 or ISBN-13 format
var regex = /^(?:ISBN(?:-1[03])?:? )?(?=[0-9X]{10}\$|↵
(?=(?:[0-9]+[- ]){3})[- 0-9X]{13}\$|97[89][0-9]{10}\$|↵
(?=(?:[0-9]+[- ]){4})[- 0-9]{17}\$)(?:97[89][- ]?)?[0-9]{1,5}[- ]?↵
[0-9]+[- ]?[0-9]+[- ]?[0-9X]\$/;

if (regex.test(subject)) {
// Remove non ISBN digits, then split into an array
var chars = subject.replace(/[- ]|^ISBN(?:-1[03])?:?/g, "").split("");
// Remove the final ISBN digit from `chars`, and assign it to `last`
var last = chars.pop();
var sum = 0;
var check, i;

if (chars.length == 9) {
// Compute the ISBN-10 check digit
chars.reverse();
for (i = 0; i < chars.length; i++) {
sum += (i + 2) * parseInt(chars[i], 10);
}
check = 11 - (sum % 11);
if (check == 10) {
check = "X";
} else if (check == 11) {
check = "0";
}
} else {
// Compute the ISBN-13 check digit
for (i = 0; i < chars.length; i++) {
sum += (i % 2 * 2 + 1) * parseInt(chars[i], 10);
}
check = 10 - (sum % 10);
if (check == 10) {
check = "0";
}
}

if (check == last) {
} else {
}
} else {
}```

### Python example, with checksum validation

```import re
import sys

subject = sys.argv[1]

# Checks for ISBN-10 or ISBN-13 format
regex = re.compile("^(?:ISBN(?:-1[03])?:? )?(?=[0-9X]{10}\$|↵
(?=(?:[0-9]+[- ]){3})[- 0-9X]{13}\$|97[89][0-9]{10}\$|↵
(?=(?:[0-9]+[- ]){4})[- 0-9]{17}\$)(?:97[89][- ]?)?[0-9]{1,5}[- ]?↵
[0-9]+[- ]?[0-9]+[- ]?[0-9X]\$")

if regex.search(subject):
# Remove non ISBN digits, then split into a list
chars = list(re.sub("[- ]|^ISBN(?:-1[03])?:?", "", subject))
# Remove the final ISBN digit from `chars`, and assign it to `last`
last = chars.pop()

if len(chars) == 9:
# Compute the ISBN-10 check digit
val = sum((x + 2) * int(y) for x,y in enumerate(reversed(chars)))
check = 11 - (val % 11)
if check == 10:
check = "X"
elif check == 11:
check = "0"
else:
# Compute the ISBN-13 check digit
val = sum((x % 2 * 2 + 1) * int(y) for x,y in enumerate(chars))
check = 10 - (val % 10)
if check == 10:
check = "0"

if (str(check) == last):
print("Valid ISBN")
else:
print("Invalid ISBN check digit")
else:
print("Invalid ISBN")```

## Discussion

An ISBN is a unique identifier for commercial books and book-like products. The 10-digit ISBN format was published as an international standard, ISO 2108, in 1970. All ISBNs assigned since January 1, 2007 are 13 digits.

ISBN-10 and ISBN-13 numbers are divided into four or five elements, respectively. Three of the elements are of variable length; the remaining one or two elements are of fixed length. All five parts are usually separated with hyphens or spaces. A brief description of each element follows:

• The group identifier identifies the language-sharing country group. It ranges from one to five digits long.

• The publisher identifier varies in length and is assigned by the national ISBN agency.

• The title identifier also varies in length and is selected by the publisher.

• The final character is called the check digit, and is computed using a checksum algorithm. An ISBN-10 check digit can be either a number from 0 to 9 or the letter X (Roman numeral for 10), whereas an ISBN-13 check digit ranges from 0 to 9. The allowed characters are different because the two ISBN types use different checksum algorithms.

All three regex solutions shown earlier are composed of similar parts, so here we’ll focus on the “ISBN-10 or ISBN-13” regex. Its leading `^(?:ISBN(?:-1[03])?:?●)?` part has three optional elements, allowing it to match any one of the following seven strings (all except the empty-string option include a space character at the end):

• `ISBN●`

• `ISBN-10●`

• `ISBN-13●`

• `ISBN:●`

• `ISBN-10:●`

• `ISBN-13:●`

• The empty string (no prefix)

After the leading `^(?:ISBN(?:-1[03])?:?●)?` that we just discussed, there is a positive lookahead that enforces one of four options (separated by the `|` alternation operator) for the length and character set of the rest of the match, as well as the number of allowed separators (zero or three for ISBN-10s, and zero or four for ISBN-13s). Because there are four alternatives within it, the lookahead is quite long. Here’s the full lookahead: `(?=[0-9X]{10}\$|(?=(?:[0-9]+[-●]){3})[-●0-9X]{13}\$|97[89][0-9]{10}\$|(?=(?:[0-9]+[-●]){4})[-●0-9]{17}\$)`. Since that’s difficult to analyze on its own, each of the four options within it are shown next. They all end with the `\$` anchor, which ensures that there cannot be any trailing text that doesn’t fit into one of the patterns:

`[0-9X]{10}\$`

Allows an ISBN-10 with no separators (10 total characters)

`(?=(?:[0-9]+[-●]){3})[-●0-9X]{13}\$`

Allows an ISBN-10 with three separators (13 total characters)

`97[89][0-9]{10}\$`

Allows an ISBN-13 with no separators (13 total characters)

`(?=(?:[0-9]+[-●]){4})[-●0-9]{17}\$`

Allows an ISBN-13 with four separators (17 total characters)

Two of these options (the ones that allow separators) include their own, nested lookaheads to ensure the right number of separators are present, before moving on to test the length of the string.

After the positive lookahead validates the length, character set, and number of separators, we can match the individual elements of the ISBN without worrying about their combined length. `(?:97[89][-●]?)?` matches the “978” or “979” prefix required by an ISBN-13. The noncapturing group is optional because it will not match within an ISBN-10 subject string. `[0-9]{1,5}[-●]?` matches the one to five digit group identifier and an optional, following separator. `[0-9]+[-●]?[0-9]+[-●]?` matches the variable-length publisher and title identifiers, along with their optional separators. Finally, `[0-9X]\$` matches the check digit at the end of the string.

Although a regular expression can check that the final digit uses a valid character (a digit or X), it cannot determine whether it’s correct for the ISBN’s checksum. One of two checksum algorithms (determined by whether you’re working with an ISBN-10 or ISBN-13) are used to provide some level of assurance that the ISBN digits haven’t been accidentally transposed or otherwise entered incorrectly. The JavaScript and Python example code shown earlier implemented both algorithms. The following sections describe the checksum rules in order to help you implement these algorithms with other programming languages.

### ISBN-10 checksum

The check digit for an ISBN-10 number ranges from 0 to 10 (with the Roman numeral X used instead of 10). It is computed as follows:

1. Multiply each of the first 9 digits by a number in the descending sequence from 10 to 2, and sum the results.

2. Divide the sum by 11.

3. Subtract the remainder (not the quotient) from 11.

4. If the result is 11, use the number 0; if 10, use the letter X.

Here’s an example of how to derive the ISBN-10 check digit for `0-596-52068-`?:

```Step 1:
sum = 10×`0` + 9×`5` + 8×`9` + 7×`6` + 6×`5` + 5×`2` + 4×`0` + 3×`6` + 2×`8`
=    0 +  45 +  72 +  42 +  30 +  10 +   0 +  18 +  16
= 233
Step 2:
233 ÷ 11 = 21, remainder 2
Step 3:
11 − 2 = 9
Step 4:
9 [no substitution required]```

The check digit is 9, so the complete sequence is `ISBN 0-596-52068-9`.

### ISBN-13 checksum

An ISBN-13 check digit ranges from 0 to 9, and is computed using similar steps:

1. Multiply each of the first 12 digits by 1 or 3, alternating as you move from left to right, and sum the results.

2. Divide the sum by 10.

3. Subtract the remainder (not the quotient) from 10.

4. If the result is 10, use the number 0.

For example, the ISBN-13 check digit for `978-0-596-52068-``?` is calculated as follows:

```Step 1:
sum = 1×`9` + 3×`7` + 1×`8` + 3×`0` + 1×`5` + 3×`9` + 1×`6` + 3×`5` + 1×`2` + 3×`0` + 1×`6` + 3×`8`
=   9 +  21 +   8 +   0 +   5 +  27 +   6 +  15 +   2 +   0 +   6 +  24
= 123
Step 2:
123 ÷ 10 = 12, remainder 3
Step 3:
10 − 3 = 7
Step 4:
7 [no substitution required]```

The check digit is 7, and the complete sequence is `ISBN 978-0-596-52068-7`.

## Variations

### Find ISBNs in documents

This adaptation of the “ISBN-10 or ISBN-13” regex uses word boundaries instead of anchors to help you find ISBNs within longer text while ensuring that they stand on their own. The “ISBN” identifier has also been made a required string in this version, for two reasons. First, requiring it helps eliminate false positives (without it, the regex could potentially match any 10- or 13-digit number), and second, ISBNs are officially required to use this identifier when printed:

```\bISBN(?:-1[03])?:?●(?=[0-9X]{10}\$|(?=(?:[0-9]+[-●]){3})↵
[-●0-9X]{13}\$|97[89][0-9]{10}\$|(?=(?:[0-9]+[-●]){4})[-●0-9]{17}\$)↵
(?:97[89][-●]?)?[0-9]{1,5}[-●]?[0-9]+[-●]?[0-9]+[-●]?[0-9X]\b```
 Regex options: None Regex flavors: .NET, Java, JavaScript, PCRE, Perl, Python, Ruby

### Eliminate incorrect ISBN identifiers

A limitation of the previous regexes is that they allow matching an ISBN-10 number preceded by the “ISBN-13” identifier, and vice versa. The following regex uses conditionals (see Recipe 2.17) to ensure that an “ISBN-10” or “ISBN-13” identifier is followed by the appropriate ISBN type. It allows both ISBN-10 and ISBN-13 numbers when the type is not explicitly specified. This regex is overkill in most circumstances because the same result could be achieved more manageably using the ISBN-10 and ISBN-13 specific regexes that were shown earlier, one at a time. It’s included here merely to demonstrate an interesting use of regular expressions:

```^
(?:ISBN(-1(?:(0)|3))?:?\ )?
(?(1)
(?(2)
# ISBN-10
(?=[0-9X]{10}\$|(?=(?:[0-9]+[- ]){3})[- 0-9X]{13}\$)
[0-9]{1,5}[- ]?[0-9]+[- ]?[0-9]+[- ]?[0-9X]
|
# ISBN-13
(?=[0-9]{13}\$|(?=(?:[0-9]+[- ]){4})[- 0-9]{17}\$)
97[89][- ]?[0-9]{1,5}[- ]?[0-9]+[- ]?[0-9]+[- ]?[0-9]
)
|
# No explicit identifier; allow ISBN-10 or ISBN-13
(?=[0-9X]{10}\$|(?=(?:[0-9]+[- ]){3})[- 0-9X]{13}\$|97[89][0-9]{10}\$|
(?=(?:[0-9]+[- ]){4})[- 0-9]{17}\$)
(?:97[89][- ]?)?[0-9]{1,5}[- ]?[0-9]+[- ]?[0-9]+[- ]?[0-9X]
)
\$```
 Regex options: Free-spacing Regex flavors: .NET, PCRE, Perl, Python