Calculating the UPS Tracking Number Check Digit

Introduction

This article serves to describe the algorithm used to calculate a UPS Tracking Number. It took me a while to figure this out, researching mostly. I thought I would make it a bit easier for others by describing it here.

Using the code

The following code is a generic method that can be used to calculate a check digit for a UPS Tracking Number. The input for the method is a string, but you could rework it to use a raw char[] if wish. This method leaves the rest of the tracking number up to you. It takes a 15 character sequence, in this case a string, and calculates the check digit using this sequence. For information sake, I will describe how the company I work for generates tracking numbers. This is up to you, as only two portions are required by UPS, the rest you can make up on your own.

1. The first two characters must be "1Z".
2. The next 6 characters we fill with our UPS account number "XXXXXX".
3. The next 2 characters denote the service type:
• "01" for Next Day Air shipments.
• "02" for Second Day Air shipments.
• "03" for Ground shipments.
4. The next 5 characters is our invoice number (our invoices are 6 digits; we drop the first digit, e.g., the 123456 invoice would yield 23456 characters).
5. The next 2 digits is the package number, zero filled. E.g., package 1 is "01", 2 is "02".
6. The last and final character is the check digit.

First of all, you will notice that the described sequence above gives us 17 characters, where as we only need 15 to calculate the check digit. To do this, we drop the "1Z" portion, and only use the last 15 characters in the method.

Next, let me take a moment to outline the algorithm used to generate the check digit. Then, you'll see the method below the outline:

1. Start a running total.
2. Examine each character in the sequence:
• If the character is in an odd position (e.g., 1^st, 3^rd, 5^th....), then:
• If the character is numeric, then add the numeric value to the running total.
• If the character is alpha, then:
• Calculate n to be (ASCII value of character - 48)
• Calculate x to be ((2 * n) - (9 * INT(n/5))) where INT(n/5) returns n/5 rounded down to the next integer (e.g., 34.3 would be 34, but 34.8 would also be 34).
• Add x to the running total.
• If the character is in an even position (e.g., 2^nd, 4^th, 6^th......), then:
• If the character is numeric, then:
• Calculate n to be (2 * the numeric value of the character).
• Add n to the running total.
• If the character is alpha, then:
• Calculate n to be (ASCII value of character - 48).
• Add n to the running total.
3. Calculate x to be (running total modulo 10)
• If x = 0, then x is the check digit.
• If x > 0, then:
• Calculate y to be (10 - x).
• y is the check digit.

Here is the method:

//
// UPS Check Digit Calculation Method
//

private int CalculateCheckDigit(String trk)
{
   int checkdigit = 0;
   char[] chars = trk.ToCharArray();
   int charindex = 1;
   int runningtotal = 0;
   foreach(Char ch in chars)
   {
      if((charindex % 2) == 0) //Indicates character in even position
      {
         int testeven;
         if(Int32.TryParse(ch.ToString(), out testeven) == true)
         // Indicates numeric value
         {
            runningtotal += (2 * testeven);
         }
         else // Indicates alpha value
         {
            int asciivalue = System.Convert.ToInt32(ch);
            int n = asciivalue - 48;
            runningtotal += n;
         }
      }
      else // Indicates character in odd position
      {
         int testodd;
         if(Int32.TryParse(ch.ToString(), out testodd) == true)
         // Indicates numeric value
         {
            runningtotal += testodd;
         }
         else // Indicates alpha value
         {
            int asciivalue = System.Convert.ToInt32(ch);
            int n = asciivalue - 48;
            int x = ((2 * n) - (9 * (int)(n / 5)));
            runningtotal += x;
         }
      }
      charindex++;
   }
   int x = (runningtotal % 10);
   if(x == 0) checkdigit = x;
   else if(x > 0) checkdigit = (10 - x);
   return checkdigit;
}