Sync App Registration Status

PUT https://api.verifik.co/v2/app-registrations/{appRegistrationId}/sync

The App Registration Sync endpoint updates the status and step of an app registration process. This endpoint is useful for syncing the registration status, especially when specific conditions or criteria have been met.

Headers

Name	Value
Content-Type	application/json
Authorization	Bearer {YOUR_ACCESS_TOKEN}

The JWT Token you should use when running the Sync is provided from the App Registration.

Query Parameters

Name	Type	Description
appRegistrationId	string	ID for the App Registration record you would like to sync

Body

Name	Type	Required	Description
step	string	Yes	Specifies the step to update, e.g., skipKYC.
status	string	Yes	The new status of the registration, e.g., COMPLETED_WITHOUT_KYC.

Step Options and Status Combinations

skipKYC Step

Status	Description	What Happens
COMPLETED_WITHOUT_KYC	Skip KYC verification	- Validates sign-up form requirements - Updates status to ONGOING if KYC steps are not mandatory - Sends data to HubSpot integration - Returns sign-up form response with token

Note: This step only works if all mandatory KYC steps (basicInformation, document, form, liveness) are not set to "mandatory" in the project flow configuration.

IMPORTANT: The skipKYC step is crucial for onboarding type flows as it provides the authentication token that users need to login to your system. This will provide your users with the token for accessing your application.

instructions Step

Status	Description	What Happens
ONGOING	Continue with instructions	- Updates status to ONGOING - Moves to next step in the flow

signUpForm Step

Status	Description	What Happens
ONGOING	Continue with sign-up form	- Validates sign-up form requirements - Updates status to ONGOING - Returns sign-up form response with token

basicInformation Step

Status	Description	What Happens
ONGOING	Continue with basic information	- Updates status to ONGOING - Moves to next step in the flow

document Step

Status	Description	What Happens
ONGOING	Continue with document verification	- Updates status to ONGOING - Returns sign-up form response with token

liveness Step

Status	Description	What Happens
ONGOING	Continue with liveness verification	- Updates status to ONGOING - Returns liveness response with token

form Step

Status	Description	What Happens
ONGOING	Continue with form completion	- Updates status to ONGOING - Moves to next step in the flow

end Step ⭐ CRUCIAL FOR ONBOARDING FLOWS

Status	Description	What Happens
COMPLETED	Complete registration successfully	- Validates all required fields and verifications - Updates status to COMPLETED - Returns authentication token for user login - Sends completion data to HubSpot integration - Triggers webhook events
FAILED	Mark registration as failed	- Updates status to FAILED - Returns authentication token for user login - Triggers webhook events
NEEDS_MANUAL_VERIFICATION	Require manual review	- Updates status to NEEDS_MANUAL_VERIFICATION - Returns authentication token for user login - Triggers webhook events

IMPORTANT: The end step is crucial for onboarding type flows as it provides the authentication token that users need to login to your system. Without completing this step, users cannot access their accounts.

Example Body

Skip KYC Example

{
  "step": "skipKYC",
  "status": "COMPLETED_WITHOUT_KYC"
}

Complete Registration Example

{
  "step": "end",
  "status": "COMPLETED"
}

Mark as Failed Example

{
  "step": "end",
  "status": "FAILED"
}

Require Manual Verification Example

{
  "step": "end",
  "status": "NEEDS_MANUAL_VERIFICATION"
}

Request

cURL

curl -X PUT 'https://api.verifik.co/v2/app-registrations/{appRegistrationId}/sync' \
  -H 'Authorization: Bearer YOUR_ACCESS_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "step": "end",
    "status": "COMPLETED"
  }'

Node.js

const axios = require('axios');

let data = JSON.stringify({
  "step": "end",
  "status": "COMPLETED"
});

let config = {
  method: 'put',
  maxBodyLength: Infinity,
  url: 'https://api.verifik.co/v2/app-registrations/{appRegistrationId}/sync',
  headers: {
    'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
    'Content-Type': 'application/json'
  },
  data: data
};

axios.request(config)
  .then((response) => {
    console.log(JSON.stringify(response.data));
  })
  .catch((error) => {
    console.log(error);
  });

Swift

import Foundation

let url = URL(string: "https://api.verifik.co/v2/app-registrations/{appRegistrationId}/sync")!
var request = URLRequest(url: url)
request.httpMethod = "PUT"
request.addValue("Bearer YOUR_ACCESS_TOKEN", forHTTPHeaderField: "Authorization")
request.addValue("application/json", forHTTPHeaderField: "Content-Type")

let jsonData: [String: Any] = [
  "step": "end",
  "status": "COMPLETED"
]

request.httpBody = try? JSONSerialization.data(withJSONObject: jsonData)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
  guard let data = data, error == nil else {
    print("Error:", error ?? "Unknown error")
    return
  }
  
  if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 {
    print("Sync successful:", String(data: data, encoding: .utf8) ?? "")
  } else {
    print("Error:", String(data: data, encoding: .utf8) ?? "")
  }
}
task.resume()

Kotlin

import okhttp3.*
import org.json.JSONObject
import java.io.IOException

val client = OkHttpClient()

val json = JSONObject()
json.put("step", "end")
json.put("status", "COMPLETED")

val requestBody = RequestBody.create(
  MediaType.parse("application/json; charset=utf-8"),
  json.toString()
)

val request = Request.Builder()
  .url("https://api.verifik.co/v2/app-registrations/{appRegistrationId}/sync")
  .put(requestBody)
  .addHeader("Authorization", "Bearer YOUR_ACCESS_TOKEN")
  .addHeader("Content-Type", "application/json")
  .build()

client.newCall(request).enqueue(object : Callback {
  override fun onFailure(call: Call, e: IOException) {
    e.printStackTrace()
  }
  
  override fun onResponse(call: Call, response: Response) {
    if (response.isSuccessful) {
      println("Sync successful: ${response.body()?.string()}")
    } else {
      println("Error: ${response.body()?.string()}")
    }
  }
})

Response

200

{
  "data": {
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
    "firstName": "John",
    "lastName": "Doe",
    "fullName": "John Doe",
    "step": "signUpForm",
    "steps": {
      "signUpForm": "mandatory",
      "basicInformation": "skip",
      "document": "mandatory",
      "liveness": "mandatory",
      "form": "skip"
    },
    "appRegistrationId": "507f1f77bcf86cd799439011",
    "status": "ONGOING"
  }
}

409

{
  "code": "Conflict",
  "message": "signUpForm_validation_not_passed"
}

What Happens After Each Step

Validation and Status Updates

• skipKYC: Validates sign-up form requirements before allowing KYC skip

• signUpForm: Ensures all mandatory sign-up information is complete

• end: Performs comprehensive validation of all required fields and verifications

Integration Points

• Webhook Events: Triggers webhook notifications for status changes

• Token Generation: Provides authentication tokens for user access

Status Flow Control

• ONGOING: Continues the registration process to the next step

• COMPLETED: Finalizes registration and provides full access

• FAILED: Marks registration as unsuccessful but still provides access token

• NEEDS_MANUAL_VERIFICATION: Requires human review before completion

Important Notes

1. Token Generation: The end step is the only step that guarantees token generation for user authentication

2. Validation Requirements: Each step may have specific validation requirements that must be met

3. KYC Skip Logic: Skipping KYC only works if no mandatory verification steps are configured

4. Webhook Integration: All status changes trigger webhook events if configured in the project flow

Common Use Cases

• Complete Registration: Use end step with COMPLETED status to finalize user registration

• Skip Verification: Use skipKYC step to bypass verification requirements when appropriate

• Manual Review: Use end step with NEEDS_MANUAL_VERIFICATION status for flagged registrations

• Step Progression: Use intermediate steps to move users through the registration flow

This endpoint provides comprehensive control over the app registration process, allowing you to manage user progression, handle edge cases, and ensure proper authentication token generation for onboarding flows.