Validating a Salesforce Id

Question

Is there a way to validate a Salesforce ID, maybe using RegEx? They are normally 15 chars or 18 chars but do they follow a pattern that we can use to check that it's a valid id.

Answer 1

There are two levels of validating salesforce id:

1. check format using regular expression [a-zA-Z0-9]{15}|[a-zA-Z0-9]{18}
2. for 18-characted ids you can check the the 3-character checksum:

Code examples provided in comments:

• C#
• Go
• Javascript
• Ruby

Answer 2

Something like this should work:

[a-zA-Z0-9]{15,18}

It was suggested that this may be more correct because it prevents Ids with lengths of 16 and 17 characters to be rejected, also we try to match against 18 char length first with 15 length as a fallback:

[a-zA-Z0-9]{18}|[a-zA-Z0-9]{15}

Answer 3

Just use instanceOf to check if the string is an instance of Id.

String s = '1234';
if (s instanceOf Id) System.debug('valid id');
else System.debug('invalid id');

Answer 4

The easiest way I've come across, is to create a new ID variable and assign a String to it.

ID MyTestID = null;
try {
    MyTestID = MyTestString; }
catch(Exception ex) { }

If MyTestID is null after trying to assign it, the ID was invalid.

Answer 5

This regex has given me the optimal results so far.

\b[a-z0-9]\w{4}0\w{12}|[a-z0-9]\w{4}0\w{9}\b

Answer 6

You can also check for 15 chars, and then add an extra 3 chars optional, with an expression similar to:

^[a-z0-9]{15}(?:[a-z0-9]{3})?$

on i mode, or not:

^[A-Za-z0-9]{15}(?:[A-Za-z0-9]{3})?$

Demo

---

If you wish to simplify/modify/explore the expression, it's been explained on the top right panel of regex101.com. If you'd like, you can also watch in this link, how it would match against some sample inputs.

---

RegEx Circuit

jex.im visualizes regular expressions:

Answer 7

Javascript: /^(?=.*?\d)(?=.*?[a-z])[a-z\d]{18}$/i

These were the Salesforce Id validation requirements for me.

1. 18 characters only
2. At least one digit
3. At least one alphabet
4. Case insensitive

Test cases

Should fail

1
a
1234
abgcde
1234aDcde
12345678901234567*
123456789012345678
abcDefghijabcdefgh

Should pass

1234567890abcDeFgh
1234abcd1234abcd12
abcd1234abcd1234ab
1abcDefhijabcdefgf
abcDefghijabcdefg1
12345678901234567a
a12345678901234567

For understanding the regex, please refer this thread

Answer 8

The regex provided by Daniel Sokolowski works perfectly to verify if the id is in the correct format.

If you want to verify if an id corresponds to an actual record in the database, you'll need to first find the object type from the first three characters (commonly known as prefix) and then query the object type:

boolean isValidAndExists(String key) {
    Map<String, Schema.SObjectType> objTypes = Schema.getGlobalDescribe();

    for (Schema.SObjectType objType : objTypes.values()) {
        Schema.DescribeSObjectResult objDesc = objType.getDescribe();
        if (objDesc.getKeyPrefix() == key.substring(0,3)) {
            String objName = objDesc.getName();
            String query = 'SELECT Id FROM ' + objName + ' WHERE Id = \'' + key + '\'';
            SObject[] objs = Database.query(query);
            return !objs.isEmpty();
        }
    }
    return false;
}

Be aware that Schema.getGlobalDescribe can be an expensive operation and degrade the performance of your application if you use that often. If you need to check that often, I recommend creating a Custom Setting or Custom Metadata to store the relation between prefixes and object types.

Answer 9

Additionally checking getSObjectType() != null would be perfect if we are dealing with Salesforce records

public static boolean isRecordId(string recordId){
    try {
        return string.isNotBlank(recordId) && ((Id)recordId.trim()).getSObjectType() != null;
    } catch(Exception ex) {
        return false;
    }
}

Answer 10

Assuming you want to validate Ids in Apex, there are a few approaches discussed in the other answers. Here is an alternative, with notes on the various approaches.

The try-catch method (credit to @matt_k) certainly works, but some folks worry about overhead, especially if testing many Ids.

I used instanceof Id for a long time (credit to @melani_s), until I discovered that it sometimes gives the wrong answer (e.g., '481D0B74-41CF-47E9').

Multiple answers suggest regexen. As the accepted answer correctly points out (credit to @zacheusz), 18 character Ids are only valid if their checksums are correct, which means the regex solutions can be wrong. That answer also helpfully provides code in several languages to test Id checksums. But not in Apex.

I was going to implement the checksum code in Apex, but then I realized the Salesforce had already done the work, so instead I just convert 18 digit Ids to 15 digit Ids (via .to15() which uses the checksum to fix capitalization, as opposed to truncating the string) and then back to 18 digits to let SF do the checksum calc, then I compare the original checksum and the new one. This is my method:

    static Pattern ID_REGEX = Pattern.compile('[a-zA-Z0-9]{15}(?:[A-Z0-5]{3})?');
    /**
     * @description Determines if a string is a valid SalesforceId.  Confirms checksum of 18 digit Ids. 
     *              Works for cases where `x instanceof id` returns the wrong answer, like '481D0B74-41CF-47E9'.
     *              Does NOT check for the existence of a record with the given Id.
     * @param s     a string to validate 
     *
     * @return      true if the string `s` is a valid Salesforce Id.
     */
    public static Boolean isValidId(String s) {
        Matcher m = ID_REGEX.matcher(s);
        if (m.matches() == false) return false;     // if it doesn't match the regex it cannot be valid
        if (s.length() == 15) return true;          // if 15 char string matches the regex, assume it must be valid
        String check = (Id)((Id)s).to15();          // Convert to 15 char Id, then to Id and back to string, giving correct 18-char Id
        return s.right(3) == check.right(3);        // if 18 char string matches the regex, valid if checksum correct
    }

Answer 11

The first 15 characters of the Salesforce Id use base-62 encoding, which consists of the lower and upper case letters a-z, A-Z and the numbers 0–9.

The last 3 characters are optional and actually can only be upper case letters A-Z and numbers between 0-5, for a set of 32 lookup table characters.

So here's the regular expression that translates this:

[a-zA-Z0-9]{15}([A-Z0-5]{3})?

If you care about the optional last 3 characters being in a non-capturing group:

[a-zA-Z0-9]{15}(?:[A-Z0-5]{3})?