NAV
Swift Java Curl

V1 Deprecation


Introduction

Authenticating is a verification platform that helps verify individuals through a variety of tests; the SDK allows companies to develop custom applications that utilize these various tests. Currently we offer solutions for iOS and Android platforms via an SDK as well as an open Api.

How The Process Works

Authenticating is very modular and allows you to only have users test what you need verified.

Step 1: Create the User

To start the Authenticating process, you first want to create a user; let’s call this user Liam. Whether Liam is taking the tests or you as the developer are sending in data to verify Liam is irrelevant, but for this example, I will explain it as if Liam is taking the tests.

You first make a call to the Create User endpoint; this will return a user object with the user’s “accessCode”. This access code is used in every call and should be given to the prospective testee (Liam) to use.

Once you have created Liam’s account, he can now start taking the respective tests you want.

Step 2: Take Tests

Liam can now start taking the tests you want him to take. You, as the developer, should limit his ability to only take the tests you want him to. For example, if you only want Liam to do the SMS verification test, only send them to a page where that test is available.

If you are running tests that run asynchronously, IE Upload ID, or Upload Passport it may take some time to confirm that they were successful. To check the status on the upload id endpoint, you can make a call to Check Upload ID or Check Upload Passport to check the status on the background process and whether or not it requires (or allows) a retry.

Once all of the tests have been completed, it is time to move on to the test results.

Step 3: Get Test Results

Make a call to the Get Test Result endpoint to return the results for the user. If the user still has time in their test window, a ‘note’ key string will indicate such, but bear in mind that if you call this endpoint and attempt to use the results of Liam’s tests before the test window has expired, Liam may not have had time to complete of the tests and it may give a false negative. We therefore recommend you wait until the test window has expired before calling this (Unless running test operations).

Getting Started


Latest SDK Version:
iOS - v1.0.0
Android - v1.0.10

iOS


Github - SDK Link:
https://github.com/HOTB-Software/Authenticating-iOS-SDK

Requirements

Installation

// Cocoapods - Podfile

target "projectTargetName" do
  use_frameworks!
  pod "AuthenticatingSDK", :path => "~/.cocoapods/repos/AuthenticatingSDK"
end


Cocoapods

Authenticating is available through CocoaPods. To install it, simply add the following line to your Podfile:

pod “Authenticating”

// Initial Configuration

AuthenticatingSDK *Authenticating = [AuthenticatingSDK shared];
[Authenticating configureWithKey:@"123a-456b-789c" venueId:@"14"];


// Initial Configuration - Use the API key provided as the authToken

import AuthenticatingSDK

AuthenticatingSDK.shared.configure(authToken: "123a-456b-789c")

Android


Github Link:
https://github.com/stevenbward/Authenticating-Android-SDK


Sample Project:
https://github.com/stevenbward/Authenticating-Android-Sample-App

Requirements


Installation


//Step 1
allprojects {
    repositories {
        maven { url 'https://jitpack.io' }
        //Don't forget this line if you are using the AppCompat Libs
        maven { url "https://maven.google.com" }
    }
}

//Step 2
android {
    dependencies {
        compile 'com.github.stevenbward:Authenticating-Android-SDK:1.0.7'
        compile 'com.squareup.retrofit2:retrofit:2.3.0'
        compile 'com.squareup.okhttp3:okhttp:3.9.0'
        compile 'com.squareup.okhttp3:logging-interceptor:3.9.0'
        compile 'com.squareup.retrofit2:converter-gson:2.3.0'
        compile 'com.google.code.gson:gson:2.8.1'
        //May be omitted 
        compile 'com.squareup.okio:okio:1.13.0'
    }
}

//Step 3 (In the Manifest Application Tag)
<application
    .
    .
    android:largeHeap="true"
    >

It is likely you will need Multi-dex enabled if you have a large number of additional libraries enabled as this includes a few dependencies of its own.

As this SDK involves uploading images (2 at a time), you will likely see OutOfMemory exceptions thrown unless you include the third line regarding largeHeap as true in your manifest file.

The Authenticating android SDK can be installed via gradle as well is using an aar file (sent upon request). Once successfully integrated, the SDK is ready to go without any custom configuration needed. See the Important Notes section for more information regarding customizing details. For more information, please feel free to Contact us:

info@authenticating.com

Toll Free (833) 2-VERIFY

9350 Wilshire Blvd, Suite 203, Beverly Hills, CA 90212

Important Notes

V1 End of Life

All new releases will move to the next version of support, but the v1 branch will remain until V1 is fully deprecated. If you would like to see said code, adjust your branch to the v1 end of life branch to see the last commits before moving to the next version.

Supported Countries

Below is a list of all supported countries with the Authenticating platform and their respective Country codes to be used when calling Create User.

All Platforms

A few important details that apply to all using the SDK:

Android

API Calls

All api calls can be found in the AuthenticatingAPICalls class. This class contains static methods which serve as a wrapper to access the API. Each of the methods contain a counterpart/ partner overloaded method that differs in that it takes in or exludes the OnTaskComplete interface listener.

If you call the method that uses the OnTaskComplete listener, the following happens:

  1. The call will be made asynchronously and will not require an AsyncTask/ thread wrapper.

  2. The method will handle the AuthenticatingError objects that can be thrown and pass them back via the listener if they occur.

  3. The method will take care of object casting and pass back the respective object with an integer tag to match the type (More on this in a moment).

If you instead want to handle the running on your own thread, do not want to use the listener, or want to get response objects back without checking for the int type, feel free to use the overloaded / mirrored methods (of the same name) which do not take in the OnTaskComplete listener as an argument.

TL;DR / Summary, every method in the AuthenticatingAPICalls will have an overloaded option that takes in a listener. If you use the one with the listener, the response will be void and is instead sent back on the interface link. If you use the one without the listener, the response is instant and requires thread management.

Logging JSON Responses

WebCallsLogging.setJsonLogging(true);

If you want to view the responses from the server in your logcat for debugging purposes, simply type the code to the right anywhere and it will set the logging to true until you specify false or remove the set to true code.

Nested Libraries

This library utilizes the following Dependencies:

Constant Integer Tags

If you choose to use the API Calls that use the OnTaskComplete listener, they will send back an integer tag that defines the return type so you don’t need to run if checks on instanceof. The int tags it uses are located in the Constants class under the misc package. I have listed the most used ones here:

Object Types

The following objects are found within the Authenticating SDK. These objects will be used in the various methods called throughout your workflow. Below is a listing of the object, its description, and a JSON Sample of it.

User Header

{
    "hasError": false,
    "code": 200,
    "data": {
        "firstName": "Pat",
        "lastName": "M",
        "companyId": "7717b830-2b94-464f-86f6-952225a9aba2",
        "userId": "1b53f070-bc1e-4d42-bb64-0f0172b9a801",
        "accessCode": "248099",
        "expirationDate": "4/5/2063 6:06:44 PM"
    }
}

This is the user obejct that is returned after a new user is created.

The accessCode in the data object is what is given to the individual taking the respective tests.

Note that the date mentioned for the expiration is in UTC.

Please see JSON sample to the right.

Check Upload Id Results

{
    "hasError": false,
    "code": 200,
    "data": {
        "result": "parsing_failed",
        "numAttemptsLeft": 1,
        "description": "Unable to detect the image. This can be cause by poor quality photos, bad lighting, glares, or other things that interfere with the image. Please try again and make sure that the id is on a consted surface (IE, a white ID on a black background or a black id on a white background)."
    }
}

This response object is used to check the status on the asyncrhonous process running after calling the uploadId endpoint. Once the numAttemptsLeft variable reaches 0, the user will no longer be permitted to upload images to the uploadId or uploadIdEnhanced endpoints.

In the response, the “result” string is an enum value which can be any of the following:

These results indicate the current status of the images being processed and the description will mirror the ones listed above as well.

Please see JSON sample to the right.

Simple Response

{
    "hasError": false,
    "code": 200,
    "data": {
        "successful" : true
    }
}

This simple response object is used in many places in the sdk. It simply indicates that the call was a success

Please see JSON sample to the right.

Test Result

{
  "hasError": false,
  "code": 200,
  "data": {
    "note": "Please note, this user still has time left to complete the test results. Their test window expires on 2018-12-31",
    "company": {
      "companyName": "HOTB Software",
      "companyId": "ABC-123"
    },
    "user": {
      "email": "myEmail@email.com",
      "phone": "5625555555",
      "userId": "123-abc",
      "accessCode": "521271",
      "firstName": "Pat",
      "lastName": "MacDowell",
      "year": 1985,
      "month": 12,
      "day": 31,
      "birthday": "1985-12-31T09:45:00Z",
      "address": "720 N Alta Dr",
      "city": "Beverly Hills",
      "state": "CA",
      "zipcode": "90210",
      "country": "USA",
      "street": null,
      "province": null,
      "buildingNumber": null
    },
    "contactProof": {
      "verifiedPhone": true,
      "verifiedEmail": false
    },
    "socialProof": {
      "successfulLogin": true
    },
    "photoProof": {
      "score": 50
    },
    "identityProof": {
      "score": 25,
      "numQuestions": 4,
      "status": "FAIL"
    },
    "idVerification": {
      "status": "PASS",
      "description": "The data from the front and the back match strongly."
    },
    "backgroundCheck": {
      "hasCriminalRecord": false
    },
    "scannedUser": {
      "Address": "720 N Alta Dr",
      "Address2": "",
      "Address3": "",
      "Address4": "",
      "Address5": "",
      "Address6": "",
      "Audit": "",
      "CSC": "",
      "City": "Beverly Hills",
      "Class": "C",
      "CountryShort": "USA",
      "County": "",
      "DateOfBirth": "12-31-85",
      "DateOfBirth4": "12-31-1985",
      "DateOfBirthLocal": "",
      "Endorsements": "NONE",
      "ExpirationDate": "12-31-25",
      "ExpirationDate4": "12-31-2025",
      "Eyes": "BRN",
      "FatherName": "",
      "Fee": "",
      "Hair": "BRN",
      "Height": "069 IN",
      "Id": "A1234567",
      "IdCountry": "United States",
      "IssueDate": "12-31-17",
      "IssueDate4": "12-31-2017",
      "IssueDateLocal": "",
      "MotherName": "",
      "NameFirst": "PAT",
      "NameLast": "MACDOWELL",
      "NameLast1": "",
      "NameLast2": "",
      "NameMiddle": "WAITFORIT",
      "NameSuffix": "",
      "Nationality": "",
      "Original": "",
      "PlaceOfBirth": "",
      "PlaceOfIssue": "",
      "Restriction": "NONE",
      "Sex": "M",
      "SigNum": "",
      "SocialSecurity": "",
      "State": "CA",
      "Text1": "",
      "Text2": "",
      "Text3": "",
      "Type": "",
      "Weight": "155",
      "Zip": "90210",
      "license": "A1234567",
      "CardType": "DRIVER LICENSE",
      "TemplateType": "DL"
    },
    "passportData" {
        "Address2": "P<MACDOWELL<<PATRICK<<<<<<<<<<<<<<<<<<<<<<<<<<",
        "Address3": "WG30004036UTO6007078M0511014<<<<<<<<<<<<<<06",
        "Country": "USA",
        "CountryLong": "",
        "DateOfBirth": "07-07-60",
        "DateOfBirth4": "07-07-1960",
        "End_POB": "S OB ZOOO",
        "ExpirationDate": "11-01-05",
        "ExpirationDate4": "11-01-2005",
        "IssueDate": "11-01-05",
        "IssueDate4": "11-01-2005",
        "NameFirst": "PATRICK",
        "NameFirst_NonMRZ": "PATRICK",
        "NameLast": "MACDOWELL",
        "NameLast_NonMRZ": "MACDOWELL",
        "NameMiddle": "",
        "Nationality": "UTO",
        "NationalityLong": "",
        "PassportNumber": "WG3000403",
        "PersonalNumber": "",
        "Sex": "M",
        "AuthenticationObject": null,
        "AuthenticationResult": "Unknown",
        "AuthenticationResultSummary": [],
        "FaceImage": null,
        "ReformattedImage": null,
        "ResponseCodeAuthorization": 0,
        "ResponseCodePassportFaceImage": 0,
        "ResponseCodePassportFaceImageDesc": null,
        "ResponseCodePassportSignatureImage": 0,
        "ResponseCodePassportSignatureImageDesc": null,
        "ResponseCodeProcPassport": 1,
        "ResponseCodeProcPassportDesc": null,
        "ResponseCodeReformatImage": 0,
        "ResponseCodeReformatImageDesc": null,
        "ResponseMessageAuthorization": null,
        "SignImage": null,
        "WebResponseCode": 1,
        "WebResponseDescription": "Successful." 
    }
  }
}

This response is the result received after a user has completed their tests and the Get Test Result api call is made.

A few important notes here:

First, if a user was not required to take a test (IE, they were not intended to take a backgroundCheck test), then the results of that test will be null within the JSON response.

Second, the “note” key indicates whether a user still has time on their test. If a user is still pending within their test window, it is recommended that you give them time to finish their tests before confirming their results.

Third, some test results, identifyProof for example, will change omit fields that are not relevant to the country of origin in which this call is being made. For example, Canadian customers would not see the “score” or “numQuestions” key / values as they are not used in that country. Also, on the identifyProof object, the status field can be one of the following: “PASS”, “FAIL”, or null. Pass means they successfully passed the test, Fail means they failed, and null means they have not yet taken the test or were not required to.

Fourth, the “scannedUser” object is the data as read from the barcode on their ID photo. If the barcode cannot be read after multiple attempts, the data fields will be filled by attempting to parse the OCR data from the front of the ID sent. Please note here that the “idVerification” object is the determination as to whether or not they passed the uploadId test while the “scannedUser” object is the parsed fields placed into the object; consequently a user could have a “scannedUser” object with data and still have failed the “idVerification” test.

Please see JSON sample to the right.

Standard Error Response

{
    "hasError": true,
    "code": 400,
    "error": {
        "successful" : false,
        "errorMessage": "access has expired or does not exist"
    }
}

This is the standard error response that will be sent back upon a failure. The errorMessage will change accordingly.

Please see JSON sample to the right.

Verify Quiz Obj

{
    "accessCode" : "521271",
    "quizId" : "123456789abcabcabcabcabc",
    "transactionID" : "abcabcabcabcabc",
    "responseUniqueId" : "abcabcabcabcabc",
    "answers" : [
        {
            "questionId" : "abcabcabcabcabc",
            "choiceId" : "abcabcabcabcabc"
        },
        {
            "questionId" : "abcabcabcabcabc",
            "choiceId" : "abcabcabcabcabc"
        },      
        {
            "questionId" : "abcabcabcabcabc",
            "choiceId" : "abcabcabcabcabc"
        },      
        {
            "questionId" : "abcabcabcabcabc",
            "choiceId" : "abcabcabcabcabc"
        }
    ]
}

This Verify Quiz Object is used whenever sending responses to questions for quizes

Please see JSON sample to the right.

Quiz Object Header

{
    "hasError": false,
    "code": 200,
    "data": {
        "transactionID": "abcabcabcabcabc",
        "responseUniqueId": "123456789",
        "quizId": "123456789",
        "numQuestions": "4",
        "question": [
            {
                "nsquestionId": "123456789",
                "nssequenceId": "1",
                "nseq": "false",
                "type": "CitiesLived",
                "text": "Which of the following CITIES have you PREVIOUSLY OR CURRENTLY used as your address?",
                "choice": [
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "1",
                        "text": "Los Angeles"
                    },
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "2",
                        "text": "New York"
                    },
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "3",
                        "text": "London"
                    },
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "4",
                        "text": "NONE OF THE ABOVE"
                    }
                ]
            },
            {
                "nsquestionId": "123465789",
                "nssequenceId": "2",
                "nseq": "false",
                "type": "RelativeBirthMonth",
                "text": "In what month was ELVIS PRESLEY born?",
                "choice": [
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "1",
                        "text": "JANUARY"
                    },
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "2",
                        "text": "MAY"
                    },
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "3",
                        "text": "MARCH"
                    },
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "4",
                        "text": "DECEMBER"
                    }
                ]
            },
            {
                "nsquestionId": "123465789",
                "nssequenceId": "3",
                "nseq": "false",
                "type": "StreetsLived",
                "text": "Which of the following STREETS have you PREVIOUSLY or CURRENTLY used as your address?",
                "choice": [
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "1",
                        "text": "Fake St"
                    },
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "2",
                        "text": "WinchestertonAve"
                    },
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "3",
                        "text": "Evergreen Terrace"
                    },
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "4",
                        "text": "Pennsylvania"
                    }
                ]
            },
            {
                "nsquestionId": "123465789",
                "nssequenceId": "4",
                "nseq": "false",
                "type": "CurrentCounty",
                "text": "In what COUNTY do you currently live?",
                "choice": [
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "1",
                        "text": "Bronx County"
                    },
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "2",
                        "text": "Kings County"
                    },
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "3",
                        "text": "Awesome County"
                    },
                    {
                        "nschoiceId": "123465789",
                        "nssequenceId": "4",
                        "text": "Oregon County"
                    }
                ]
            }
        ]
    }
}

This object is the structure of quiz questions returned to users to answer utilizing the verifyQuiz endpoint.

Please see JSON sample to the right.

Available Networks Header

{
    "hasError": false,
    "code": 200,
    "data": [
        "facebook",
        "instagram",
        "twitter"
    ]
}

This returns a list of Strings that are the current available social media networks a user can log in with. If someone attempts to verify with a network that is not on this approved list, the test will fail.

This response comes from the Get Available Social Networks endpoint.

Please see JSON sample to the right.

Social Network Obj

{
    "accessCode" : "521271",
    "network" : "facebook",
    "socialMediaAccessToken" : "abc-123-321-cba",
    "socialMediaUserId" : "abc-def"
}

This object is used to verify a user’s social media test. Once they have successfully logged into a social media on the approved list Here, send a request to verifySocialNetworks with the data shown here.

Please see JSON sample to the right.

Methods

Get User

AuthenticatingSDK.shared.getUser(accessCode: "1234") { (user, errorMessage) in
    if errorMessage != nil {
        print(errorMessage)
        return
    }

    print(user)
}

//Get the User Object
AuthenticatingAPICalls.getUser(new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TYPE_USER_HEADER){
                    UserHeader userHeader = (UserHeader) result;
                    if(userHeader != null) {
                        UserHeader.User user = userHeader.getUser();
                    }
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        }, COMPANY_API_KEY, USER_ACCESS_CODE);
);


curl -XPOST -H 'Content-Type: application/json' -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -d '{
    "accessCode" : "521271"
}' 'http://api.Authenticating.com/api/v1/getUser

This endpoint pings the server to get the user object. If the access code is expired, no user data will be returned.

This call returns a User Header Object

Update User

AuthenticatingSDK.shared.updateUser(accessCode: "1234", email: "user@user.com", phone: 111-111-1111, firstName: "John", lastName: "Doe", address: "123 First St.", city: "Irvine", state: "CA", zipCode: "92618", month: 6, day: 1, year: 1976, ssn: nil) { (user, errorMessage) in
    if errorMessage != nil {
        print(errorMessage)
        return
    }

    print(user)
}

//Update The User Object
AuthenticatingAPICalls.updateUser(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object o, int i) {
                if(i == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) o;
                    Log.d("Authenticating", "A error has occurred: " + e.getAuthErrorString());
                } else if(i == AuthenticatingConstants.TAG_USER_HEADER){
                    UserHeader u = (UserHeader) o;
                }
            }
        }, COMPANY_COMPANY_API_KEY, USER_ACCESS_CODE,
        firstName, lastName, yearInt, monthInt, dayInt, address,
        city, state, postalCode, street, province, buildingNumber, email, phone, ssn
);

//Or pass in a User object you build yourself
AuthenticatingAPICalls.updateUser(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object o, int i) {
                if(i == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) o;
                    Log.d("Authenticating", "A error has occurred: " + e.getAuthErrorString());
                } else if(i == AuthenticatingConstants.TAG_USER_HEADER){
                    UserHeader u = (UserHeader) o;
                }
            }
        }, COMPANY_COMPANY_API_KEY, USER_ACCESS_CODE, aUserObject
);



curl -XPOST -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -H "Content-type: application/json" -d '{
    "accessCode" : "636224",
    "email" : "email@email.com",
    "phone" : "2135555555",
    "firstName" : "Patrick",
    "lastName" : "MacDowell",
    "address" : "123 Fake St",
    "city" : "Los Angeles",
    "state" : "CA",
    "street" : "Rue Delaney",
    "province" : "ON",
    "buildingNumber" : "123",
    "zipCode" : "90210",
    "month" : 10,
    "day" : 8,
    "year" : 1985,
    "ssn" : "123456789"
}' 'http://api.Authenticating.com/api/v1/updateUser'

This endpoint will update the user object. This is used when taking certain tests that require updated information. An example would be the identity quiz test or the Canadian authentication check, both of which require the user to fill out information like name, address / street, state / province, birthday, etc. Update the user and then make the respective call.

This call returns a User Header Object

Of Special Note:

Although this does contain the option to send the Social Security number, please only do so if requested to within a response. Most of the time, we are able to successfully identify a person without need of their ss#. There are times, however, where there is very little information on a person and a social is required in order to properly find them. If the endpoint sends back an error indicating that there is not enough information and everything else has been filled out, then request it from a user.

Verify Phone

AuthenticatingSDK.shared.verifyPhone(accessCode: "1234") { (response, errorMessage) in
    if errorMessage != nil {
        print(errorMessage)
        return
    }

    print(response)
}

//Send the phone number for verification
AuthenticatingAPICalls.verifyPhone(new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TAG_SIMPLE_RESPONSE_OBJ){
                    SimpleResponseObj o = (SimpleResponseObj) result;
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        }, COMPANY_API_KEY, USER_ACCESS_CODE);
);


curl -XPOST -H 'Content-Type: application/json' -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -d '{
    "accessCode" : "521271"
}' 'http://api.Authenticating.com/api/v1/verifyPhone'

This is used to start the phone number verification process.

A phone number is included in the call and an SMS is sent to the user. Once they receive the SMS with the code, they enter it into a field and a subsequent call is made to verifyPhoneCode.

This call returns a Simple Response Object

Verify Phone Code

AuthenticatingSDK.shared.verifyPhoneCode(accessCode: "1234", smsCode: "4321") { (response, errorMessage) in
    if errorMessage != nil {
        print(errorMessage)
        return
    }

    print(response)
}

//Send the sms code received by phone number for verification
AuthenticatingAPICalls.verifyPhoneCode(new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TAG_SIMPLE_RESPONSE_OBJ){
                    SimpleResponseObj o = (SimpleResponseObj) result;
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        }, COMPANY_API_KEY, USER_ACCESS_CODE, SMS_CODE);
);


curl -XPOST -H 'Content-Type: application/json' -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -d '{
    "accessCode" : "521271",
    "code" : "120820"
}' 'http://api.Authenticating.com/api/v1/verifyPhoneCode'

This is used to complete the phone number verification process.

The user receives an SMS with a code. That code is sent on this endpoint and confirms their completion of the test.

This call returns a Simple Response Object

Verify Email

AuthenticatingSDK.shared.verifyEmail(accessCode: "1234") { (response, errorMessage) in
    if errorMessage != nil {
        print(errorMessage)
        return
    }

    print(response)
}

//Send a verification email to the email a user has on file
AuthenticatingAPICalls.verifyEmail(new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TAG_SIMPLE_RESPONSE_OBJ){
                    SimpleResponseObj o = (SimpleResponseObj) result;
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        }, COMPANY_API_KEY, USER_ACCESS_CODE);
);


curl -XPOST -H 'Content-Type: application/json' -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -d '{
    "accessCode" : "521271"
}' 'http://api.Authenticating.com/api/v1/verifyEmail'

This is used to complete the email verification process.

The user receives an email with a link. When the user clicks on said link, it will complete the verification process.

This call returns a Simple Response Object

Compare Photos

guard let image = UIImage(named: "imageOne") else { return }
let image1Data = UIImageJPEGRepresentation(image, 0.9)
guard let img1Base64 = image1Data?.base64EncodedString(options: Data.Base64EncodingOptions(rawValue: 0)) else { return }
guard let img1Str = img1Base64.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) else { return }


guard let image2 = UIImage(named: "imageTwo") else { return }
let image2Data = UIImageJPEGRepresentation(image2, 0.9)
guard let img2base64 = image2Data?.base64EncodedString(options: Data.Base64EncodingOptions(rawValue: 0)) else { return }
guard let img2Str = img2base64.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) else { return }

AuthenticatingSDK.shared.comparePhotos(accessCode: "1234", img1: img1Base64, img2: img2base64) { (response, errorMessage) in
    if errorMessage != nil {
        print(errorMessage)
        return
    }

    print(response)
}

//Complete the photo verification endpoint using 2 bitmaps
AuthenticatingAPICalls.comparePhotos(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TAG_SIMPLE_RESPONSE_OBJ){
                    SimpleResponseObj o = (SimpleResponseObj) result;
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        },
        COMPANY_API_KEY, USER_ACCESS_CODE, bitmapImage1, bitmapImage2
);

//Complete the photo verification endpoint using 2 already base64 encoded strings
AuthenticatingAPICalls.comparePhotos(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TAG_SIMPLE_RESPONSE_OBJ){
                    SimpleResponseObj o = (SimpleResponseObj) result;
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        },
        COMPANY_API_KEY, USER_ACCESS_CODE, base64EncodedImageString1, base64EncodedImageString2
);


curl -XPOST -H 'Content-Type: application/json' -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -d '{
    "accessCode" : "521271",
    "img1" : "BASE_64_ENCODED_IMAGE_STRING_GOES_HERE",
    "img2" : "BASE_64_ENCODED_IMAGE_STRING_GOES_HERE"
}' 'http://api.Authenticating.com/api/v1/comparePhotos'

This is used to complete the photo verification process. Note that the endpoint receives 2 base64 encoded Strings as the images.

For Android: please note that this is a Post call and will likely be a lengthy one. There are multiple overloaded methods if you want to utilize your own progress or thread management, however it is recommended that you use the method that runs everything within an asynctask and manages the bitmap to base 64 string conversion on its own background thread. If you want to encode them yourself and send the Strings, the overloaded method will handle this.

The correct implementation is to compare a photo from a user’s library (Local gallery, social media photo, etc) with a selfie taken using the camera on the user’s phone. The proper workflow is to force the end user to select and upload a profile picture from the library on the mobile device and then upload a selfie they just took using their camera.

Important Notes:

1) In this example, we wrote both the first and second photo to be obtained via the camera, which if copied directly will not follow the guidelines mentioned above. Please make sure that the first photo included will be from a source other than the camera.

2) This call does not return an indicator as to whether or not they actually passed the photo verification, this endpoint returns a success if the 2 images sent were successfully uploaded and saved to the database; the image comparison runs asynchronously.

3) The maximum allowed size of the image uploaded (per image) is capped at 2MB. Please do not send in photos larger than 2MB as an exception will be thrown. If you are using the Android SDK, the overloaded API call will automatically resize the image for you to fit specifications.

This call returns a Simple Response Object

Upload ID



//Complete the photo verification endpoint using 2 bitmaps
AuthenticatingAPICalls.uploadId(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TAG_SIMPLE_RESPONSE_OBJ){
                    SimpleResponseObj o = (SimpleResponseObj) result;
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        },
        COMPANY_API_KEY, USER_ACCESS_CODE, bitmapImageFront, bitmapImageBack
);

//Complete the photo verification endpoint using 2 already base64 encoded strings
AuthenticatingAPICalls.uploadId(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TAG_SIMPLE_RESPONSE_OBJ){
                    SimpleResponseObj o = (SimpleResponseObj) result;
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        },
        COMPANY_API_KEY, USER_ACCESS_CODE, base64EncodedImageFront, base64EncodedImageBack
);


curl -XPOST -H 'Content-Type: application/json' -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -d '{
    "accessCode" : "521271",
    "idFront" : "BASE_64_ENCODED_IMAGE_STRING_GOES_HERE",
    "idBack" : "BASE_64_ENCODED_IMAGE_STRING_GOES_HERE"
}' 'http://api.Authenticating.com/api/v1/uploadId'

This is used to complete the ID verification process. Note that the endpoint receives 2 base64 encoded Strings as the images.

For Android: please note that this is a Post call and will likely be a lengthy one. There are multiple overloaded methods if you want to utilize your own progress or thread management, however it is recommended that you use the method that runs everything within an asynctask and manages the bitmap to base 64 string conversion on its own background thread. If you want to encode them yourself and send the Strings, the overloaded method will handle this.

The correct implementation is take in the front of the photo (generally the front contains the user’s photo and some information) and send it as the 'idFront’ key while sending the back of the photo (generally the back contains barcodes, IE, PDF 417 barcodes) and set it as the 'idBack’ key.

Important Notes:

1) This call does not return an indicator as to whether or not they actually passed the ID verification, this endpoint returns a success if the 2 images sent were successfully uploaded and saved to the database; the image processing runs asynchronously.

2) You must ensure that the photos being uploaded are what the user intends to submit as they will not be told of their success upon upload. We recommend creating a confirm popup with both images to make sure users understand the photos they are uploading.

3) The maximum allowed size of the image uploaded (per image) is capped at 2MB. Please do not send in photos larger than 2MB as an exception will be thrown. If you are using the Android SDK, the overloaded API call will automatically resize the image for you to fit specifications.

This call returns a Simple Response Object

Upload ID Enhanced



//Complete the photo verification endpoint using 2 bitmaps
AuthenticatingAPICalls.uploadIdEnhanced(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TAG_SIMPLE_RESPONSE_OBJ){
                    SimpleResponseObj o = (SimpleResponseObj) result;
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        },
        COMPANY_API_KEY, USER_ACCESS_CODE, bitmapImageFront, bitmapImageBack
);

//Complete the photo verification endpoint using 2 already base64 encoded strings
AuthenticatingAPICalls.uploadIdEnhanced(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TAG_SIMPLE_RESPONSE_OBJ){
                    SimpleResponseObj o = (SimpleResponseObj) result;
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        },
        COMPANY_API_KEY, USER_ACCESS_CODE, base64EncodedImageFront, base64EncodedImageBack
);


curl -XPOST -H 'Content-Type: application/json' -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -d '{
    "accessCode" : "521271",
    "idFront" : "BASE_64_ENCODED_IMAGE_STRING_GOES_HERE",
    "idBack" : "BASE_64_ENCODED_IMAGE_STRING_GOES_HERE"
}' 'http://api.Authenticating.com/api/v1/uploadIdEnhanced'

This is used to complete the ID verification process. This endpoint is near identical to the Upload ID endpoint other than it runs additional checks against the information sent in with stricter requirements to pass.

Note! The per-cost use of this call is more expensive than Upload ID. Please contact support for pricing information.

This call returns a Simple Response Object

Check Upload ID




//Check the status on the uploaded id
AuthenticatingAPICalls.checkUploadId(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TYPE_CHECK_PHOTO_RESULTS_HEADER){
                    CheckPhotoResultsHeader o = (CheckPhotoResultsHeader) result;
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        },
        COMPANY_API_KEY, USER_ACCESS_CODE
);


curl -XPOST -H 'Content-Type: application/json' -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -d '{
    "accessCode" : "521271"
}' 'http://api.Authenticating.com/api/v1/checkUploadId'

This is used to determine if the uploadId asynchronous process has finished. Depending on a myriad of factors, the processing on passed document images can take a varying amount of time (indeterminite) and can cause problems for developers if they are wanting immediate results, this endpoint, therefore, helps to determine the current 'status’ of that operation. This can also be used to determine if a user should make another attempt if the image could not be read, IE due to lighting or blurry issues.

In the response, the “result” string is an enum value which can be any of the following:

These results indicate the current status of the images being processed.

This call returns a Check Upload Id Results Object

Upload Passport



//Complete the upload Passport endpoint with the passport image
AuthenticatingAPICalls.uploadPassport(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TAG_SIMPLE_RESPONSE_OBJ){
                    SimpleResponseObj o = (SimpleResponseObj) result;
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        },
        COMPANY_API_KEY, USER_ACCESS_CODE, passportImage
);

//Complete the upload Passport endpoint with the passport image
AuthenticatingAPICalls.uploadPassport(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TAG_SIMPLE_RESPONSE_OBJ){
                    SimpleResponseObj o = (SimpleResponseObj) result;
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        },
        COMPANY_API_KEY, USER_ACCESS_CODE, base64EncodedPassportImage
);


curl -XPOST -H 'Content-Type: application/json' -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -d '{
    "accessCode" : "521271",
    "idFront" : "BASE_64_ENCODED_IMAGE_STRING_GOES_HERE"
}' 'http://api.Authenticating.com/api/v1/uploadPassport'

This is being used to upload a passport image to be scanned and parsed. The image should be of the page with the user’s information on it (generally on the first or second page). It is one picture that captures both pages of the passport. This follows the same logic as the other uploadId endpoints in that the picture needs to be clear, it needs to have minimal glare, and it must have sufficient lighting.

This call is an asyncrhonous one and the data will be returned whenever getTestResult is eventually triggered. To check the progress on this call and make sure nothing was missed, utilize the checkUploadPassport endpoint.

To see a sample passport image of the page that needs to be included, please see this link or this one.

This call returns a Simple Response Object

Check Upload Passport




//Check the status on the uploaded id
AuthenticatingAPICalls.checkUploadPassport(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TYPE_CHECK_PHOTO_RESULTS_HEADER){
                    CheckPhotoResultsHeader o = (CheckPhotoResultsHeader) result;
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        },
        COMPANY_API_KEY, USER_ACCESS_CODE
);


curl -XPOST -H 'Content-Type: application/json' -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -d '{
    "accessCode" : "521271"
}' 'http://api.Authenticating.com/api/v1/checkUploadPassport'

This is used to determine if the uploadPassport asynchronous process has finished. Depending on a myriad of factors, the processing on passed document images can take a varying amount of time (indeterminite) and can cause problems for developers if they are wanting immediate results, this endpoint, therefore, helps to determine the current 'status’ of that operation. This can also be used to determine if a user should make another attempt if the image could not be read, IE due to lighting or blurry issues.

In the response, the “result” string is an enum value which can be any of the following:

These results indicate the current status of the images being processed.

This call returns a Check Upload Id Results Object

Get Available Social Networks

AuthenticatingSDK.shared.getAvailableSocialNetworks(accessCode: "1234") { (response, errorMessage) in
    if errorMessage != nil {
        print(errorMessage)
        return
    }

    print(response)
}

//Get the social networks available for a user to verify with
AuthenticatingAPICalls.getAvailableNetworks(new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TAG_AVAILABLE_NETWORKS){
                    List<String> networks = ((AvailableNetworksHeader) result).getNetworkOptions();
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        }, COMPANY_API_KEY, USER_ACCESS_CODE);


curl -XPOST -H 'Content-Type: application/json' -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -d '{
    "accessCode" : "521271"
}' 'http://api.Authenticating.com/api/v1/getAvailableNetworks'

This is used to obtian the approved list of social networks that a user may use to verify the Social Proof test.

The returned list of strings (from the object) will either be empty if none have been set or will contain strings of network types. Examples could be: Google, Instagram, Twitter, Facebook, etc.

This call returns a Available Networks Header Object

Verify Social Networks

AuthenticatingSDK.shared.verifySocialNetworks(accessCode: "1234", network: "Facebook", socialMediaAccessToken: "1234", socialMediaUserId: "1234") { (response, errorMessage) in
    if errorMessage != nil {
        print(errorMessage)
        return
    }

    print(response)
}

//Complete the Social Proof Test
AuthenticatingAPICalls.verifySocialNetworks(new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object result, int customTag) {
                if(customTag == AuthenticatingConstants.TAG_SIMPLE_RESPONSE_OBJ){
                    SimpleResponseObj o = (SimpleResponseObj) result;
                } else if(customTag == AuthenticatingConstants.TAG_ERROR_RESPONSE){
                    AuthenticatingException e = (AuthenticatingException) result;
                    String error = e.getAuthErrorString();
                }
            }
        }, COMPANY_API_KEY, USER_ACCESS_CODE, NETWORK_NAME, USER_ACCESS_TOKEN, USER_ID);


curl -XPOST -H 'Content-Type: application/json' -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -d '{
    "accessCode" : "521271",
    "network" : "facebook",
    "socialMediaAccessToken" : "abc-123-321-cba",
    "socialMediaUserId" : "abc-def"
}' 'http://api.Authenticating.com/api/v1/verifySocialNetworks'

This is used to complete the social proof test. The network name String passed in as a param are the very same ones obtained from the getAvailableNetworks call above.

The USER_ACCESS_TOKEN is the user’s access / auth token you obtain after the user successfully logs into their social media account.

The USER_ID is the user’s id you obtain after the user successfully logs into their social media account.

This call returns a Simple Response Object

Get Identity Proof Quiz

AuthenticatingSDK.shared.getIdentityProofQuiz(accessCode: "1234") { (response, errorMessage) in
    if errorMessage != nil {
        print(errorMessage)
        return
    }

    print(response)
}

//Get the identity proof quiz questions
AuthenticatingAPICalls.getQuiz(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object o, int i) {
                listener.showOrHideLoadingAnimation(false);
                if (i == AuthenticatingConstants.TAG_ERROR_RESPONSE) {
                    AuthenticatingException e = (AuthenticatingException) o;
                    Log.d("Authenticating", "An error has Occurred: " +
                            e.getAuthErrorString());
                } else if (i == AuthenticatingConstants.TAG_QUIZ_QUESTIONS_HEADER) {
                    QuizObjectHeader quizes = (QuizObjectHeader) o;
                    quizObject = quizes.getQuizObject();
                    if(quizObject != null){
                        questions = quizObject.getQuizQuestions();
                        //Utilize Questions here
                    }
                }
            }
        }, COMPANY_API_KEY, USER_ACCESS_CODE
);


curl -XPOST -H 'Content-Type: application/json' -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -d '{
    "accessCode" : "636224"
}' 'http://api.Authenticating.com/api/v1/getQuiz'

This endpoint will access records to find a list of questions for the user to answer and prove their identity. If the user cannot be found with their current entered information, it will reply with what information is missing (IE, their birthday); in which case a call should be made to updateUser and then a reattempt here. Note! If the user cannot be found from the information provided after all updateUser methods have been exhauseted, they will be asked to also include their Social Security number.

This call returns a Quiz Object Header

Verify Quiz

AuthenticatingSDK.shared.verifyQuiz(accessCode: "1234", quizId: "18393214", transactionId: "613113096-613103096", responseUniqueId: "620432141", questionOneId: "48208200285", choiceOneId: "292251694", questionTwoId: "48208200286", choiceTwoId: "298251699", questionThreeId: "48208200287", choiceThreeId: "298251700", questionFourId: "48208200288", choiceFourId: "298251706") { (response, errorMessage) in
    if errorMessage != nil {
        print(errorMessage)
        return
    }

    print(response)
}

//Complete the Identity quiz by using the questions received.
AuthenticatingAuthenticatingAPICalls.verifyQuiz(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object o, int i) {

                //Regardless of pass or fail, make sure to clear data here for security//

                if (i == AuthenticatingConstants.TAG_ERROR_RESPONSE) {
                    AuthenticatingException e = (AuthenticatingException) o;
                    Log.d("Authenticating", "An error has Occurred: " +
                            e.getAuthErrorString());
                } else if (i == AuthenticatingConstants.TAG_SIMPLE_RESPONSE_OBJ) {
                    SimpleResponseObj s = (SimpleResponseObj) o;
                    if(s != null) {
                        SimpleResponseObj.SimpleResponse ss = s.getSimpleResponse();
                        if(ss != null){
                            boolean passedTest = ss.getSuccess();
                        }
                    }
                }
            }
        }, COMPANY_API_KEY, ACCESS_CODE,
        answersArray, quizId, transactionId, responseUniqueId
);


curl -XPOST -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -H "Content-type: application/json" -d '{
    "accessCode" : "636224",
    "quizId" : "123456789asdasdasd",
    "transactionID" : "osfh9sh9ffsffswa",
    "responseUniqueId" : "dhuaeiofefs",
    "answers" : [
        {
            "questionId" : "hd9wd80ywd9d-ahd1",
            "choiceId" : "se0f9js0jfmf1"
        },
        {
            "questionId" : "hd9wd80ywd9d-ahd2",
            "choiceId" : "se0f9js0jfmf2"
        },      
        {
            "questionId" : "hd9wd80ywd9d-ahd3",
            "choiceId" : "se0f9js0jfmf3"
        },      
        {
            "questionId" : "hd9wd80ywd9d-ahd4",
            "choiceId" : "se0f9js0jfmf4"
        }
    ]
}' 'http://api.Authenticating.com/api/v1/verifyQuiz'

This is used to complete the identity proof quiz. The users will give their answers to the multiple choice questions and this will score their results.

This call returns a Simple Response Object

Generate Criminal Background Report

AuthenticatingSDK.shared.generateCriminalBackgroundReport(accessCode: "1234") { (response, errorMessage) in
    if errorMessage != nil {
        print(errorMessage)
        return
    }

    print(response)
}

//Generate the background report
AuthenticatingAPICalls.generateBackgroundReport(
        new OnTaskCompleteListener() {
            @Override
            public void onTaskComplete(Object o, int i) {
                if (i == AuthenticatingConstants.TAG_ERROR_RESPONSE) {
                    AuthenticatingException e = (AuthenticatingException) o;
                    o.getAuthErrorString();
                } else if (i == AuthenticatingConstants.TAG_SIMPLE_RESPONSE_OBJ) {
                    Log.d("Authenticating", "Success!");
                    //Background report was successfully generated (though not visible via response)
                }
            }
        }, COMPANY_API_KEY, USER_ACCESS_CODE
);


curl -XPOST -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -H "Content-type: application/json" -d '{
    "accessCode" : "636224"
}' 'http://api.Authenticating.com/api/v1/generateCriminalReport'

This will generate a criminal background report for the user. The results are not returned, but are persisted server-side.

Please note that you must complete an Identity proof quiz before you can take this one. Attempting the opposite order will throw an exception by the server.

The USER_ACCESS_CODE is the user’s access / auth token you obtain after the user successfully logs into their social media account.

This call returns a Simple Response Object

Create User


curl -XPOST -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -H "Content-type: application/json" -d '{
        "firstName" : "Patrick",
        "lastName" : "MacDowell",
        "email" : "email@email.com",
        "phone" : "2135555555",
        "country" : "USA",
        "companyAdminKey" : "7722b819-2b51-414f-f670-910735affff2"
    }' 'http://api.Authenticating.com/api/v1/createUser'

This endpoint creates a user. It is designed to be used by admins within the company to create a user account before they are given the access code.

Note, all fields listed above are required and an error will be thrown if one or more is omitted.

The country value matches that of a list of Country codes. USA for United States, CAN for Canada, etc. For a full list of supported countries, please see this list

This call returns a User Header Object

Please Note that this is not included within the Android and IOS SDKs.

Set Social Networks


curl -XPOST -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -H "Content-type: application/json" -d '{
        "companyAdminKey" : "7722b819-2b51-414f-f670-910735affff2",
        "networks" : [
            "facebook",
            "instagram",
            "twitter"
        ]
    }' 'http://api.Authenticating.com/api/v1/setAvailableNetworks'

This endpoint sets the available social networks for individuals taking a test. For example, if you only send facebook and instagram, then a user will not be permitted to pass social media authentication using Twitter; they would need to use one of the permitted ones you passed in.

This call returns a Simple Response Object

Please Note that this is not included within the Android and IOS SDKs.

Set Contact Required


curl -XPOST -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -H "Content-type: application/json" -d '{
    "companyAdminKey" : "7722b819-2b51-414f-f670-910735affff2",
    "isPhoneRequired" : true,
    "isEmailRequired" : false
}' 'http://api.Authenticating.com/api/v1/setContactRequired'

This endpoint sets the requirement for your tests to need both email and phone in order to pass. This defaults to both being required (both true) so that those you choose to take the Contact Proof test must complete both email and phone verification.

If you wish to never require one of those two, IE never requiring phone verification, then simply set this to false and only email will be required to pass.

This call returns a Simple Response Object

Please Note that this is not included within the Android and IOS SDKs.

Set Minimum Photo Percent


curl -XPOST -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -H "Content-type: application/json" -d '{
    "companyAdminKey" : "7722b819-2b51-414f-f670-910735affff2",
    "percent" : 40
}' 'http://api.Authenticating.com/api/v1/setPhotoMatchPercent'

This endpoint sets the minimum percentage match needed to pass the photo verification; it defaults to 40% for a pass. You can alter this number if you choose, but we recommend you keep it at 40% as our testing has shown that this is a good base-line number to determine accuracy. Setting it to a higher number, like 80%, will likely cause many people to fail the test.

This call returns a Simple Response Object

Please Note that this is not included within the Android and IOS SDKs.

Set Days To Expire


curl -XPOST -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -H "Content-type: application/json" -d '{
    "companyAdminKey" : "7722b819-2b51-414f-f670-910735affff2",
    "days" : 3
}' 'http://api.Authenticating.com/api/v1/setDaysToExpire'

This endpoint sets the number of 24 hour periods in which a person can complete their test. This is initialized at 3 days when a user is created. If you want to change this to a different amount, for example 7 days or just 1, simply use this endpoint to change how it will effect all of your future test takers.

This call returns a Simple Response Object

Please Note that this is not included within the Android and IOS SDKs.

Get Test Result


curl -XPOST -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -H "Content-type: application/json" -d '{
    "companyAdminKey" : "7722b819-2b51-414f-f670-910735affff2",
    "accessCode" : "636224"
}' 'http://api.Authenticating.com/api/v1/getTestResult'

This endpoint retrieves the test results for a single individual. If the user still has time left to complete the tests, a note will be added to the response to indicate such.

This call returns a Test Result Object

Please Note that this is not included within the Android and IOS SDKs.

Get Test Results


curl -XPOST -H 'authKey: YOUR_COMPANY_API_KEY_GOES_HERE' -H "Content-type: application/json" -d '{
    "companyAdminKey" : "7722b819-2b51-414f-f670-910735affff2",
    "accessCodes" : ["636224","123456","654321"]
}' 'http://api.Authenticating.com/api/v1/getTestResults'

This endpoint retrieves the test results for a bulk set of individuals. If the users still have time left to complete the tests, a note will be added to the response (within each object) to indicate such.

This call returns an array of Test Result Objects

Please Note that this is not included within the Android and IOS SDKs.

FAQ

General

Where do I sign up for an account?

You can sign up for an account here. Once you fill out the form, you will be contacted by a representative for the next steps.

Why do I need to create a User?

Users are created by company administrators because it helps encapsulate details and protects you from being over charged. If we added this functionality into the app, people could create multiple accounts for other people, which could lead to you being charged for tests which you did not intend.

How much does each test cost? Is it cheaper to run tests in Bundles?

Please contact your representative for pricing details. Discounts are available based on volume. As additional checks are added, bundle pricing may be an option.

Android

These docs are nice, but where is my Javadoc?

Got ya covered. JavaDocs can be downloaded here or viewed here.

I see these constant int tags everywhere but where are they coming from?

They are located in the AuthenticatingConstants class, nested under the networking package. You can use your own custom tags with the onTaskComplete listener and the AuthenticatingAPICalls that do not require the listener if you wish.

I am having gradle issues

You might be seeing: “TransformException: DuplicateEntry” or “zipException”: It means that there are multiple versions of the same library in your gradle file. This happens when you include a library that is already nested within this SDK. An example would be if you included Gson / Retrofit / Okhttp in your project when this one already has it.

You can also use these libraries the exact same way you normally would as they are included via a nested Jar file in the SDK.

Pro Tip: click on your manifest and then at the bottom of it (where you would normally alternate between xml and visual on UI) you will see a tab for “Merged Manifest”. This will give you more details on problems and usually how to fix them.

If that still doesn’t fix the issue, try this: Use the following code in your build.gradle file to solve the issue

android {
    configurations {
        all*.exclude group: 'com.squareup.okhttp3', module: 'okhttp'
    }
}

Where is the Sample Android app and why is it not in with the SDK examples?

The Sample app can be found here. It was made separately on purpose as we wanted the ability to install it on to a phone via an SDK and run it with minimal inclusion.

Can I obfuscate my code without it affecting the SDK functionality?

Sure! If you happen to spot any bugs or reasons why it does not work, just contact us and we will fix it asap. In the interim, just keep the package in your proguard file.

ios

Swift Java Curl