NAV Navbar
cURL Python Java Ruby Go NodeJS C# PHP Perl C++ Scala
  • Introduction
  • Authentication
  • Users
  • Groups
  • Enrollments
  • Verification
  • Identification
  • Content Languages
  • Response Codes
  • Errors
  • Introduction

    VoiceIt API 2.0 Technology Preview!

    Make sure you have curl installed
    https://curl.haxx.se

    Note, voiceit2 wrapper only works for Python 3, and hence, will not be available on the Python 2 pip package manager.

    Use pip to get the VoiceIt module.
    pip3 install voiceit2

    #Import the module
    from voiceit2 import VoiceIt2
    

    We recommend using jitpack to grab the wrapper into your project. Add the following to pom.xml if you are using Maven for you project:

    <repositories>
      ...
      <repository>
          <id>jitpack.io</id>
          <url>https://jitpack.io</url>
      </repository>
      ...
    </repositories>
    
    <dependencies>
      ...
      <dependency>
        <groupId>com.github.voiceittech</groupId>
        <artifactId>VoiceIt2-Java</artifactId>
        <version>JAVA_VERSION_HERE</version>
      </dependency>
      ...
    </dependencies>
    

    For Gradle, you may need to disable offline mode in case you are using Intellij. We also recommend using Java 8. Add the following to your Gradle build file:

    allprojects {
       repositories {
         ...
         maven { url 'https://jitpack.io' }
       }
     }
    dependencies {
             implementation 'com.github.voiceittech:VoiceIt2-Java:0.0.4'
     }
    

    Please make sure you have the rest client installed

    gem install rest-client

    Install VoiceIt2's gem

    gem install VoiceIt2

    #Require the wrapper
    require 'VoiceIt2'
    

    Install the voiceit go module first

    go get github.com/voiceittech/voiceit2-go

    //Make sure to add the import statement
    import (
      voiceit2 "github.com/voiceittech/voiceit2-go"
    )
    

    Install the voiceit2 package via npm

    npm install --save voiceit2-nodejs


    Note, the examples presented here use some newer features only available in ES6.

    //Make sure to require the project
    const voiceit2 = require('voiceit2-nodejs');
    

    The VoiceIt2 module can easily be fetched from nuget command line tool:

    https://www.nuget.org/packages/VoiceIt/

    dotnet add package VoiceIt --version


    However, for most most cases involving C# development in Visual Studio IDE, we suggest retreiving the package package through Visual Studio's "Add Packages" user interface.

    In VS, right click on "Packages" in the solutions column, click on "Add Packages...", then search for "VoiceIt". After finding the package, click the checkbox and click "Add Package" button at the bottom right of the pop-up dialogue box.



    In order to utilize the wrapper, include the VoiceIt2 namespace at the top of your code:

    using VoiceIt2API;

    Get the wrapper by directly downloading the file from Github :

    https://github.com/voiceittech/VoiceIt2-PHP

    under voiceit/VoiceIt2.php and include in your project

    <?php
    include('VoiceIt2.php');
    ?>
    

    Or, use composer via the command line to get the package :

    composer require voiceit-php/voiceit2

    <?php
    //Make sure to add this at top when using composer
    require_once 'vendor/autoload.php';
    ?>
    

    To use the Perl wrapper, please download the perl file from our repository and add it to the root of your project folder. Make sure you have the following modules installed:

    HTTP::Requests::Common
    LWP::Protocol::https
    LWP::UserAgent


    To install using the prefered method of cpan, enter thecpan CLI tool, then type: install <Package Name> to install the aforementioned packages.

    Make sure to require the voiceIt2 module in your program.

    require "./voiceIt2.pm";
    

    This wrapper will return string objects which can be parsed as JSON objects. The parse_json() function from the package JSON::Parse is particularly suited to retreive values for specific fields from JSON strings.


    Note: This package has been tested on Perl 5 version 28, and should be compatible with other verions of Perl 5. However, the changes introduced in Perl 6 renders it incompatible with our wrapper.

    The C++ wrapper is available as a C++ header at the Github page and has two dependencies.

    1. JSON For Modern C++
    2. C++ Requests: Curl for People

    Include the JSON header file from json.hpp in the same directory you downloaded the VoiceIt2 header. The cURL wrapper will take a few steps to be able to use. You can follow the steps on their page to set up with the CPR dependency.

    Once you install the dependency locally, you will need to use CMake to manage the dependencies. Here is an example CMakeLists.txt for a set-up involving a file Source.cpp to create a executable ProjectName.

    set (CMAKE_CXX_STANDARD 11)
    project (ProjectName)
    cmake_minimum_required(VERSION 2.8.12)
    add_subdirectory(cpr)
    include_directories(${CPR_INCLUDE_DIRS})
    add_executable(ProjectName Source.cpp)

    In order to utilize the wrapper, include the header in your program as follows:

    #include "VoiceIt2.hpp";
    

    The Scala wrapper is available as a JitPack pacakge repository. In order to utilize it in your project you will need to add the JitPack resolver and our package dependency to build.sbt in your project root.

    resolvers += "jitpack" at "https://jitpack.io"
    libraryDependencies += "com.github.voiceittech" % "voiceit2-scala" %

    Note: Please define an SBT version 1.0.0 or newer in project/build.properties in order to use this wrapper. Furthermore, the package relies on the HTTP package and the Stream package of the Akka framework. You will need to pass a callback function to the methods as the first parameter to handle the returned JSON formatted string. Check out this example if you need help getting started.

    Anytime we refer to the optional doBlinkDetection parameter in the center column, it will be mandatory to supply a valid boolean value for the Scala wrapper.

    In order to utilize the wrapper, import the class in your program as follows:

    import voiceit2.VoiceIt2
    

    API 2.0 can be used to add Voice + Face Verification and Identification to your projects. You can view code examples in the dark area to the right, and you can switch the programming language of the examples with the tabs in the top right.

    Authentication

    Initialize VoiceIt by passing in your API credentials

    Basic Authentication

    Parameter Type Description Required
    apiKey String Your API 2.0 key True
    apiToken String Your API 2.0 token True
    With shell, you can just use the -u flag to pass the credentials
    without having to manually base64 encode them
    
    curl -u <apiKey>:<apiToken> "https://api.voiceit.io"
    
    my_voiceit = VoiceIt2('<apiKey>','<apiToken>')
    
    VoiceIt2 myVoiceIt = new VoiceIt2("<apiKey>","<apiToken>");
    
    myVoiceIt = VoiceIt2.new("<apiKey>", "<apiToken>")
    
    myVoiceIt := voiceit2.NewClient("<apiKey>", "<apiToken>")
    
    let myVoiceIt = new voiceit2("<apiKey>", "<apiToken>");
    
    VoiceIt2 myVoiceIt = new VoiceIt2("<apiKey>", "<apiToken>");
    
    <?php
    $myVoiceIt = new VoiceIt\VoiceIt2("<apiKey>", "<apiToken>");
    ?>
    
    my $myVoiceIt = voiceIt2->new("<apiKey>","<apiToken>");
    
    VoiceIt2 myVoiceIt("<apiKey>", "<apiToken>");
    
    VoiceIt2 myVoiceIt("<apiKey>", "<apiToken>")
    

    Make sure to replace <apiKey> with your API key and <apiToken> with your auth token.

    VoiceIt uses an API Key and Authorization Token to allow access to the API. You can sign up for a VoiceIt developer account, and view your credentials from the settings tab under the developer console.

    Requests are authenticated using HTTP Basic Auth. Provide your API key as the basic auth username and the the Auth token as the basic auth password. Thus, you can build the authorization header manually by base64 encoding your credentials in the format API_KEY_HERE:AUTH_TOKEN_HERE resulting in something like QVBJX0tFWV9IRVJFOkFFVEhfVE9LRU5fSEVSRQ==, then add that to the authorization header like this:

    Authorization: Basic QVBJX0tFWV9IRVJFOkFFVEhfVE9LRU5fSEVSRQ==

    Users

    Get all Users

    curl -u <apiKey>:<apiToken> "https://api.voiceit.io/users"
    
    my_voiceit.get_all_users()
    
    myVoiceIt.getAllUsers();
    
    myVoiceIt.getAllUsers()
    
    myVoiceIt.GetAllUsers()
    
    myVoiceIt.getAllUsers((jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.GetAllUsers();
    
    <?php
    $myVoiceIt->getAllUsers();
    ?>
    
    $myVoiceIt->getAllUsers();
    
    myVoiceIt.GetAllUsers();
    
    myVoiceIt.getAllUsers((jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
    "message":"Successfully got all users",
    "count":2,
    "status":200,
    "timeTaken":"0.009s",
    "users":
    [
      {
        "createdAt": 1486672854000,
        "userId": "usr_49c98304252549239775e2b52a84006a"
      },
      {
        "createdAt": 1487026658000,
        "userId": "usr_feb6d1fcd80448628db8ec6a7ddb6322"
      }
    ],
    "responseCode":"SUCC"
    }
    

    This endpoint retrieves all the users for an API Key.

    HTTP Request

    GET https://api.voiceit.io/users

    Parameters

    No additional parameters needed for this request just basic authentication and a GET request to the end point.

    SUCC
    See detailed descriptions for response codes here

    Create a User

    curl -u <apiKey>:<apiToken> -X POST "https://api.voiceit.io/users"
    
    my_voiceit.create_user()
    
    myVoiceIt.createUser();
    
    myVoiceIt.createUser()
    
    myVoiceIt.CreateUser()
    
    myVoiceIt.createUser((jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.CreateUser();
    
    <?php
    $myVoiceIt->createUser();
    ?>
    
    $myVoiceIt->createUser();
    
    myVoiceIt.CreateUser();
    
    myVoiceIt.createUser((jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Created user with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322",
        "status": 201,
        "timeTaken": "0.055s",
        "createdAt": 1487026658000,
        "userId": "usr_feb6d1fcd80448628db8ec6a7ddb6322",
        "responseCode":"SUCC"
    }
    

    This endpoint creates a new user in the system and returns a unique userId.

    HTTP Request

    POST https://api.voiceit.io/users

    Parameters

    No additional parameters needed for this request just basic authentication and a POST request to the end point.

    SUCC
    See detailed descriptions for response codes here

    Check If a Specific User Exists

    curl -u <apiKey>:<apiToken> "https://api.voiceit.io/users/<userId>"
    
    my_voiceit.check_user_exists("<userId>")
    
    myVoiceIt.checkUserExists("<userId>");
    
    myVoiceIt.checkUserExists("<userId>")
    
    myVoiceIt.CheckUserExists("<userId>")
    
    myVoiceIt.checkUserExists({
      userId :"<userId>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.CheckUserExists("<userId>");
    
    <?php
    $myVoiceIt->checkUserExists("<userId>");
    ?>
    
    $myVoiceIt->checkUserExists("<userId>");
    
    myVoiceIt.CheckUserExists("<userId>");
    
    myVoiceIt.checkUserExists("<userId>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
    "message":"User with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322 exists",
    "exists":true,
    "status":200,
    "timeTaken":"0.007s",
    "responseCode":"SUCC"
    }
    

    This endpoint retrieves a specific user with the given userId.

    HTTP Request

    GET https://api.voiceit.io/users/<userId>

    URL Parameters

    Parameter Type Description Required
    userId String The ID of the user True

    SUCC
    See detailed descriptions for response codes here

    Delete a Specific User

    curl -u <apiKey>:<apiToken> -X DELETE "https://api.voiceit.io/users/<userId>"
    
    my_voiceit.delete_user("<userId>")
    
    myVoiceIt.deleteUser("<userId>");
    
    myVoiceIt.deleteUser("<userId>")
    
    myVoiceIt.DeleteUser("<userId>")
    
    myVoiceIt.deleteUser({
      userId :"<userId>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.DeleteUser("<userId>");
    
    <?php
    $myVoiceIt->deleteUser("<userId>");
    ?>
    
    $myVoiceIt->deleteUser("<userId>");
    
    myVoiceIt.DeleteUser("<userId>");
    
    myVoiceIt.deleteUser("<userId>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Deleted user with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322",
        "status": 200,
        "timeTaken": "0.037s",
        "responseCode":"SUCC"
    }
    

    This endpoint deletes a specific user with the given userId.

    HTTP Request

    DELETE https://api.voiceit.io/users/<userId>

    URL Parameters

    Parameter Type Description Required
    userId String The ID of the user True

    SUCC and UNFD
    See detailed descriptions for response codes here

    Get Groups for User

    curl -u <apiKey>:<apiToken> "https://api.voiceit.io/users/<userId>/groups"
    
    my_voiceit.get_groups_for_user("<userId>")
    
    myVoiceIt.getGroupsForUser("<userId>");
    
    myVoiceIt.getGroupsForUser("<userId>")
    
    myVoiceIt.GetGroupsForUser("<userId>")
    
    myVoiceIt.getGroupsForUser({
      userId :"<userId>"
    },(jsonResponse)=>{
      //handle response
      });
    
    myVoiceIt.GetGroupsForUser("<userId>");
    
    <?php
    $myVoiceIt->getGroupsForUser("<userId>");
    ?>
    
    $myVoiceIt->getGroupsForUser("<userId>");
    
    myVoiceIt.GetGroupsForUser("<userId>");
    
    myVoiceIt.getGroupsForUser("<userId>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
    "message":"Successfully returned all groups that user with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322 is a part of",
    "groups":["grp_4225f88a571f4bd790b51a91109bab88", "grp_801e4d6dc1e941bf9165ba5c84bd94d2"],
    "count":0,
    "status":200,
    "timeTaken":"0.007s",
    "responseCode":"SUCC"
    }
    

    This endpoint retrieves a list of groups that the user with the given userId is a part of

    HTTP Request

    GET https://api.voiceit.io/users/<userId>/groups

    URL Parameters

    Parameter Type Description Required
    userId String The ID of the user True

    SUCC and UNFD
    See detailed descriptions for response codes here

    Groups

    Get all Groups

    curl -u <apiKey>:<apiToken> "https://api.voiceit.io/groups"
    
    my_voiceit.get_all_groups()
    
    myVoiceIt.getAllGroups();
    
    myVoiceIt.getAllGroups()
    
    myVoiceIt.GetAllGroups()
    
    myVoiceIt.getAllGroups((jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.GetAllGroups();
    
    <?php
    $myVoiceIt->getAllGroups();
    ?>
    
    $myVoiceIt->getAllGroups();
    
    myVoiceIt.GetAllGroups();
    
    myVoiceIt.getAllGroups((jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
    "message":"Successfully got all groups",
    "count":1,
    "status":200,
    "timeTaken":"0.009s",
    "groups":
    [
      {
        "createdAt": 1486672854000,
        "description": "Main Group",
        "groupId" : "grp_4225f88a571f4bd790b51a91109bab88",
        "users" : ["usr_feb6d1fcd80448628db8ec6a7ddb6322"]
      }
    ],
    "responseCode":"SUCC"
    }
    

    This endpoint retrieves all the groups for an API Key.

    HTTP Request

    GET https://api.voiceit.io/groups

    Parameters

    No additional parameters needed for this request just basic authentication and a GET request to the end point.

    SUCC
    See detailed descriptions for response codes here

    Get a Specific Group

    curl -u <apiKey>:<apiToken> "https://api.voiceit.io/groups/<groupId>"
    
    my_voiceit.get_group("<groupId>")
    
    myVoiceIt.getGroup("<groupId>");
    
    myVoiceIt.getGroup("<groupId>")
    
    myVoiceIt.GetGroup("<groupId>")
    
    myVoiceIt.getGroup({
      groupId : "<groupId>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.GetGroup("<groupId>");
    
    <?php
    $myVoiceIt->getGroup("<groupId>");
    ?>
    
    $myVoiceIt->getGroup("<groupId>");
    
    myVoiceIt.GetGroup("<groupId>");
    
    myVoiceIt.getGroup("<groupId>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Successfully returned group with groupId : grp_4225f88a571f4bd790b51a91109bab88",
        "description": "Family",
        "groupId": "grp_4225f88a571f4bd790b51a91109bab88",
        "createdAt": 1486991883000,
        "users": [ "usr_feb6d1fcd80448628db8ec6a7ddb6322" ],
        "status": 200,
        "timeTaken": "0.008s",
        "responseCode" : "SUCC"
    }
    

    This endpoint retrieves the group and associated fields for the group with the given groupId

    HTTP Request

    GET https://api.voiceit.io/groups/<groupId>

    URL Parameters

    Parameter Type Description Required
    groupId String The ID of the group True

    SUCC and GNFD
    See detailed descriptions for response codes here

    Check if Group Exists

    curl -u <apiKey>:<apiToken> "https://api.voiceit.io/groups/<groupId>/exists"
    
    my_voiceit.group_exists("<groupId>")
    
    myVoiceIt.groupExists("<groupId>");
    
    myVoiceIt.groupExists("<groupId>")
    
    myVoiceIt.CheckGroupExists("<groupId>")
    
    myVoiceIt.checkGroupExists({
      groupId : "<groupId>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.GroupExists("<groupId>");
    
    <?php
    $myVoiceIt->groupExists("<groupId>");
    ?>
    
    $myVoiceIt->groupExists("<groupId>");
    
    myVoiceIt.CheckGroupExists("<groupId>");
    
    myVoiceIt.checkGroupExists("<groupId>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
      "message": "Group with groupId : grp_4225f88a571f4bd790b51a91109bab88 exists",
      "exists": true,
      "status": 200,
      "timeTaken": "0.001s",
      "responseCode" : "SUCC"
    }
    

    This endpoint can be used to check if a group with the given groupId exists

    HTTP Request

    GET https://api.voiceit.io/groups/<groupId>/exists

    URL Parameters

    Parameter Type Description Required
    groupId String The ID of the group True

    SUCC
    See detailed descriptions for response codes here

    Create a Group

    curl -u <apiKey>:<apiToken> -F "description=<description>" -X POST "https://api.voiceit.io/groups"
    
    my_voiceit.create_group("<description>")
    
    myVoiceIt.createGroup("<description>");
    
    myVoiceIt.createGroup("<description>")
    
    myVoiceIt.CreateGroup("<description>")
    
    myVoiceIt.createGroup({
      description: "<description>")=>{
      //handle response
    });
    
    myVoiceIt.CreateGroup("<description>");
    
    <?php
    $myVoiceIt->createGroup("<description>");
    ?>
    
    $myVoiceIt->createGroup("<description>");
    
    myVoiceIt.CreateGroup("<description>");
    
    myVoiceIt.createGroup("<description>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Created group with groupId : grp_801e4d6dc1e941bf9165ba5c84bd94d2",
        "description": "Family",
        "groupId": "grp_801e4d6dc1e941bf9165ba5c84bd94d2",
        "status": 201,
        "createdAt" : 1487026658000,
        "timeTaken": "0.011s",
        "responseCode" : "SUCC"
    }
    

    This endpoint creates a new group in the system and returns a unique groupId.

    HTTP Request

    POST https://api.voiceit.io/groups

    Request Parameters

    Parameter Type Description Required
    description String An optional description help identify the group False

    SUCC
    See detailed descriptions for response codes here

    Add User to Group

    curl -u <apiKey>:<apiToken> \
    -F "groupId=<groupId>" \
    -F "userId=<userId>" \
    -X PUT "https://api.voiceit.io/groups/addUser"
    
    my_voiceit.add_user_to_group("<groupId>", "<userId>")
    
    myVoiceIt.addUserToGroup("<groupId>", "<userId>");
    
    myVoiceIt.addUserToGroup("<groupId>", "<userId>")
    
    myVoiceIt.AddUserToGroup("<groupId>", "<userId>")
    
    myVoiceIt.addUserToGroup({
      userId : "<userId>",
      groupId : "<groupId>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.AddUserToGroup("<groupId>", "<userId>");
    
    <?php
    $myVoiceIt->addUserToGroup("<groupId>", "<userId>");
    ?>
    
    $myVoiceIt->addUserToGroup("<groupId>", "<userId>");
    
    myVoiceIt.AddUserToGroup("<groupId>", "<userId>");
    
    myVoiceIt.addUserToGroup("<groupId>", "<userId>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Successfully added user with userId : usr_49c98304252549239775e2b52a84006a to group with groupId : grp_801e4d6dc1e941bf9165ba5c84bd94d2",
        "status": 200,
        "timeTaken": "0.002s",
        "responseCode" : "SUCC"
    }
    

    This endpoint adds a specific user with the given userId to a specific group with the given groupId.

    HTTP Request

    PUT https://api.voiceit.io/groups/addUser

    Request Parameters

    Parameter Type Description Required
    userId String The ID of the user True
    groupId String The ID of the group True

    SUCC, MISP, FAIL, GNFD and UNFD
    See detailed descriptions for response codes here

    Remove User from Group

    curl -u <apiKey>:<apiToken> \
    -F "groupId=<groupId>" \
    -F "userId=<userId>" \
    -X PUT "https://api.voiceit.io/groups/removeUser"
    
    my_voiceit.remove_user_from_group("<groupId>", "<userId>")
    
    myVoiceIt.removeUserFromGroup("<groupId>", "<userId>");
    
    myVoiceIt.removeUserFromGroup( "<groupId>", "<userId>")
    
    myVoiceIt.RemoveUserFromGroup( "<groupId>", "<userId>")
    
    myVoiceIt.removeUserFromGroup({
      userId : "<userId>",
      groupId : "<groupId>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.RemoveUserFromGroup( "<groupId>", "<userId>");
    
    <?php
    $myVoiceIt->removeUserFromGroup("<groupId>", "<userId>");
    ?>
    
    $myVoiceIt->removeUserFromGroup("<groupId>", "<userId>");
    
    myVoiceIt.RemoveUserFromGroup("<groupId>", "<userId>");
    
    myVoiceIt.removeUserFromGroup("<groupId>", "<userId>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Successfully removed user usr_49c98304252549239775e2b52a84006a from group with groupId : grp_801e4d6dc1e941bf9165ba5c84bd94d2",
        "status": 200,
        "timeTaken": "0.002s",
        "responseCode" : "SUCC"
    }
    

    This endpoint removes a specific user with the given userId from a specific group with the given groupId.

    HTTP Request

    PUT https://api.voiceit.io/groups/removeUser

    Request Parameters

    Parameter Type Description Required
    userId String The ID of the user True
    groupId String The ID of the group True

    SUCC, MISP, FAIL, GNFD, and UNFD
    See detailed descriptions for response codes here

    Delete a Specific Group

    curl -u <apiKey>:<apiToken> -X DELETE "https://api.voiceit.io/groups/<groupId>"
    
    my_voiceit.delete_group("<groupId>")
    
    myVoiceIt.deleteGroup("<groupId>");
    
    myVoiceIt.deleteGroup("<groupId>")
    
    myVoiceIt.DeleteGroup("<groupId>")
    
    myVoiceIt.deleteGroup({
      groupId : "<groupId>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.DeleteGroup("<groupId>");
    
    <?php
    $myVoiceIt->deleteGroup("<groupId>");
    ?>
    
    $myVoiceIt->deleteGroup("<groupId>");
    
    myVoiceIt.DeleteGroup("<groupId>");
    
    myVoiceIt.deleteGroup("<groupId>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this

    {
        "message": "Successfully deleted group with groupId : grp_801e4d6dc1e941bf9165ba5c84bd94d2",
        "status": 200,
        "timeTaken": "0.037s",
        "responseCode":"SUCC"
    }
    

    This endpoint deletes a specific group with the given groupId.

    HTTP Request

    DELETE https://api.voiceit.io/groups/<groupId>

    URL Parameters

    Parameter Type Description Required
    groupId String The ID of the group True

    SUCC and GNFD
    See detailed descriptions for response codes here

    Enrollments

    Get All Enrollments for User

    curl -u <apiKey>:<apiToken> "https://api.voiceit.io/enrollments/<userId>"
    
    my_voiceit.get_all_enrollments_for_user("<userId>")
    
    myVoiceIt.getAllEnrollmentsForUser("<userId>");
    
    myVoiceIt.getAllEnrollmentsForUser("<userId>")
    
    myVoiceIt.GetAllEnrollmentsForUser("<userId>")
    
    myVoiceIt.getAllEnrollmentsForUser({
      userId : "<userId>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.GetAllEnrollmentsForUser("<userId>");
    
    <?php
    $myVoiceIt->getAllEnrollmentsForUser("<userId>");
    ?>
    
    $myVoiceIt->getAllEnrollmentsForUser("<userId>");
    
    myVoiceIt.GetAllEnrollmentsForuser("<userId>");
    
    myVoiceIt.getAllEnrollmentsForUser("<userId>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
    "message":"Successfully got all enrollments for user with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322",  
    "count":2,
    "status":200,
    "timeTaken":"0.079s",
    "enrollments":
    [
      {
        "createdAt": 1487026658003,
        "contentLanguage": "en-US",
        "enrollmentId": 73,
        "text": "never forget tomorrow is a new day"
      },
      {
        "createdAt": 1487026658000,
        "contentLanguage": "en-US",
        "enrollmentId": 79,
        "text": "never forget tomorrow is a new day"
      }
    ],
    "responseCode":"SUCC"
    }
    

    This endpoint retrieves all the enrollments for a user.

    HTTP Request

    GET https://api.voiceit.io/enrollments/<userId>

    URL Parameters

    Parameter Type Description Required
    userId String The ID of the user True

    SUCC and UNFD
    See detailed descriptions for response codes here

    Get User's Face Enrollments

    curl -u <apiKey>:<apiToken> "https://api.voiceit.io/enrollments/face/<userId>"
    
    my_voiceit.get_face_enrollments_for_user("<userId>")
    
    myVoiceIt.getFaceEnrollmentsForUser("<userId>");
    
    myVoiceIt.getFaceEnrollmentsForUser("<userId>")
    
    myVoiceIt.GetFaceEnrollmentsForUser("<userId>")
    
    myVoiceIt.getFaceEnrollmentsForUser({
      userId : "<userId>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.GetFaceEnrollmentsForUser("<userId>");
    
    <?php
    $myVoiceIt->getFaceEnrollmentsForUser("<userId>");
    ?>
    
    $myVoiceIt->getFaceEnrollmentsForUser("<userId>");
    
    myVoiceIt.GetFaceEnrollmentsForuser("<userId>");
    
    myVoiceIt.getFaceEnrollmentsForUser("<userId>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
    "message":"Successfully got all face enrollments for user with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322",
    "count":2,
    "status":200,
    "timeTaken":"0.079s",
    "faceEnrollments":
    [
      {
        "createdAt": 1486672854000,
        "faceEnrollmentId": 23
      },
      {
        "createdAt": 1487026658000,
        "faceEnrollmentId": 45
      }
    ],
    "responseCode":"SUCC"
    }
    

    This endpoint retrieves all the face enrollments for a user.

    HTTP Request

    GET https://api.voiceit.io/enrollments/face/<userId>

    URL Parameters

    Parameter Type Description Required
    userId String The ID of the user True

    SUCC and UNFD See detailed descriptions for response codes here

    Create Voice Enrollment

    curl -u <apiKey>:<apiToken> -X POST \
      -F "userId=<userId>" \
      -F "contentLanguage=<contentLanguage>" \
      -F "recording=@<recording>" \
      "https://api.voiceit.io/enrollments"
    
    my_voiceit.create_voice_enrollment("<userId>", "<contentLanguage>", "<recording>")
    
    myVoiceIt.createVoiceEnrollment("<userId>", "<contentLanguage>", <recording>);
    
    myVoiceIt.createVoiceEnrollment("<userId>", "<contentLanguage>", "<recording>")
    
    myVoiceIt.CreateVoiceEnrollment("<userId>", "<contentLanguage>", "<recording>")
    
    myVoiceIt.createVoiceEnrollment({
      userId : "<userId>",
      contentLanguage : "<contentLanguage>",
      audioFilePath : "<recording>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.CreateVoiceEnrollment("<userId>", "<contentLanguage>", "<recording>");
    
    <?php
    $myVoiceIt->createVoiceEnrollment("<userId>", "<contentLanguage>", "<recording>");
    ?>
    
    $myVoiceIt->createVoiceEnrollment("<userId>", "<contentLanguage>", "<recording>");
    
    myVoiceIt.CreateVoiceEnrollment("<userId>", "<contentLanguage>", "<recording>");
    
    myVoiceIt.createVoiceEnrollment("<userId>", "<contentLanguage>", "<recording>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
    "message": "Successfully enrolled voice for user with userId : usr_49c98304252549239775e2b52a84006a",
    "contentLanguage": "en-US",
    "id": 57,
    "status": 201,
    "text": "never forget tomorrow is a new day",
    "textConfidence": 100.00,
    "createdAt": 1487026658000,
    "timeTaken": "7.718s",
    "responseCode" : "SUCC"
    }
    

    This endpoint creates a new voice enrollment in the system for the given user

    HTTP Request

    POST https://api.voiceit.io/enrollments

    Request Parameters

    Parameter Type Description Required
    userId String The ID of the user True
    contentLanguage String Choose from a list of 88 content language parameters True
    recording File / String The binary audio data uploaded as a file. Our wrappers also accept the absolute path to the audio file ( we recommend a wav formatted audio file) True

    SUCC, MISP, DDNE, IFAD, SRNR, SSTQ, SSTL, NEHSD, STTF, RWPU and UNFD
    See detailed descriptions for response codes here

    Create Voice Enrollment by URL

    curl -u <apiKey>:<apiToken> -X POST \
      -F "userId=<userId>" \
      -F "contentLanguage=<contentLanguage>" \
      -F "fileUrl=<fileUrl>" \
      "https://api.voiceit.io/enrollments/byUrl"
    
    my_voiceit.create_voice_enrollment_by_url("<userId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.createVoiceEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.createVoiceEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.CreateVoiceEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.createVoiceEnrollmentByUrl({
      userId : "<userId>",
      contentLanguage : "<contentLanguage>",
      audioFileURL : "<fileUrl>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.CreateVoiceEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    <?php
    $myVoiceIt->createVoiceEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    ?>
    
    $myVoiceIt->createVoiceEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.CreateVoiceEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.createVoiceEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
    "message": "Successfully enrolled voice for user with userId : usr_49c98304252549239775e2b52a84006a",
    "contentLanguage": "en-US",
    "id": 57,
    "status": 201,
    "text": "never forget tomorrow is a new day",
    "textConfidence": 100.00,
    "createdAt": 1487026658000,
    "timeTaken": "7.718s",
    "responseCode" : "SUCC"
    }
    

    This endpoint creates a new voice enrollment in the system for the given user

    HTTP Request

    POST https://api.voiceit.io/enrollments/byUrl

    Request Parameters

    Parameter Type Description Required
    userId String The ID of the user True
    contentLanguage String Choose from a list of 88 content language parameters True
    fileUrl String A fully qualified URL to the audio file to be used for enrollment True

    SUCC, MISP, DDNE, IFAD, SRNR, SSTQ, SSTL, NEHSD, STTF, RWPU and UNFD
    See detailed descriptions for response codes here

    Create Face Enrollment

    curl -u <apiKey>:<apiToken> -X POST \
      -F "userId=<userId>" \
      -F "video=@<video>" \
      "https://api.voiceit.io/enrollments/face"
    
    my_voiceit.create_face_enrollment("<userId>",  "<video>")
    
    myVoiceIt.createFaceEnrollment("<userId>", "<video>");
    
    myVoiceIt.createFaceEnrollment("<userId>", "<video>")
    
    myVoiceIt.CreateFaceEnrollment("<userId>", "<video>")
    
    myVoiceIt.createFaceEnrollment({
      userId : "<userId>",
      videoFilePath : "<video>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.CreateFaceEnrollment("<userId>", "<video>");
    
    <?php
    $myVoiceIt->createFaceEnrollment("<userId>", "<video>");
    ?>
    
    $myVoiceIt->createFaceEnrollment("<userId>", "<video>");
    
    myVoiceIt.CreateFaceEnrollment("<userId>", "<video>");
    
    myVoiceIt.createFaceEnrollment("<userId>", "<video>", false, (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Successfully enrolled face for user with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322",
        "status": 201,
        "blinksCount": 1,
        "createdAt": 1486672854000,
        "timeTaken": "5.055s",
        "faceEnrollmentId":34,
        "responseCode":"SUCC"
    }
    

    This endpoint creates a new face enrollment in the system for the given user

    HTTP Request

    POST https://api.voiceit.io/enrollments/face

    Request Parameters

    Parameter Type Description Required
    userId String The ID of the user True
    video File / String The binary video data uploaded as a file. Our wrappers also accept the absolute path to the video file ( we recommend an mp4 formatted video) True
    doBlinkDetection Boolean Is set to false by default ( In order to get the blinksCount from the JSON response, set to true. This may increase the processing time of the API call ) False

    SUCC, MISP, FTMF, FNFD and UNFD
    See detailed descriptions for response codes here

    Create Video Enrollment

    curl -u <apiKey>:<apiToken> -X POST \
      -F "userId=<userId>" \
      -F "contentLanguage=<contentLanguage>" \
      -F "doBlinkDetection=false" \
      -F "video=@<video>" \
      "https://api.voiceit.io/enrollments/video"
    
    my_voiceit.create_video_enrollment("<userId>", "<contentLanguage>", "<video>")
    
    myVoiceIt.createVideoEnrollment("<userId>", "<contentLanguage>", "<video>");
    
    myVoiceIt.createVideoEnrollment("<userId>", "<contentLanguage>", "<video>")
    
    myVoiceIt.CreateVideoEnrollment("<userId>", "<contentLanguage>", "<video>")
    
    myVoiceIt.createVideoEnrollment({
      userId : "<userId>",
      contentLanguage : "<contentLanguage>",
      videoFilePath : "<video>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.CreateVideoEnrollment("<userId>", "<contentLanguage>", "<video>");
    
    <?php
    $myVoiceIt->createVideoEnrollment("<userId>", "<contentLanguage>", "<video>");
    ?>
    
    $myVoiceIt->createVideoEnrollment("<userId>", "<contentLanguage>", "<video>");
    
    myVoiceIt.CreateVideoEnrollment("<userId>", "<contentLanguage>", "<video>");
    
    myVoiceIt.createVideoEnrollment("<userId>", "<contentLanguage>", "<video>", false, (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
    "message": "Successfully enrolled video for user with userId : usr_49c98304252549239775e2b52a84006a",
    "contentLanguage": "en-US",
    "id": 57,
    "status": 201,
    "text": "never forget tomorrow is a new day",
    "textConfidence": 100.00,
    "createdAt": 1487026658000,
    "timeTaken": "4.718s",
    "responseCode" : "SUCC"
    }
    

    This endpoint creates a new voice + face enrollment in the system for the given user

    HTTP Request

    POST https://api.voiceit.io/enrollments/video

    Request Parameters

    Parameter Type Description Required
    userId String The ID of the user True
    contentLanguage String Choose from a list of 88 content language parameters True
    video File / String The binary video data uploaded as a file. Our wrappers also accept the absolute path to the video file ( we recommend an mp4 formatted video) True
    doBlinkDetection Boolean Is set to false by default ( to get the blinksCount from the JSON response, set to true. This may increase the processing time of the API call ) False

    SUCC, MISP, DDNE, IFVD, SRNR, SSTQ, SSTL, NEHSD, STTF, RWPU, FTMF, FNFD, and UNFD
    See detailed descriptions for response codes here

    Create Video Enrollment by URL

    curl -u <apiKey>:<apiToken> -X POST \
      -F "userId=<userId>" \
      -F "contentLanguage=<contentLanguage>" \
      -F "fileUrl=<fileUrl>" \
      "https://api.voiceit.io/enrollments/video/byUrl"
    
    my_voiceit.create_video_enrollment_by_url("<userId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.createVideoEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.createVideoEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.CreateVideoEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.createVideoEnrollmentByUrl({
      userId : "<userId>",
      contentLanguage : "<contentLanguage>",
      videoFileURL : "<fileUrl>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.CreateVideoEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    <?php
    $myVoiceIt->createVideoEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    ?>
    
    $myVoiceIt->createVideoEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.CreateVideoEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.createVideoEnrollmentByUrl("<userId>", "<contentLanguage>", "<fileUrl>", false, (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
    "message": "Successfully enrolled video for user with userId : usr_49c98304252549239775e2b52a84006a",
    "contentLanguage": "en-US",
    "id": 57,
    "status": 201,
    "blinksCount":1,
    "text": "never forget tomorrow is a new day",
    "textConfidence": 100.00,
    "createdAt": 1487026658000,
    "timeTaken": "7.718s",
    "responseCode" : "SUCC"
    }
    

    This endpoint creates a new voice + face enrollment in the system for the given user

    HTTP Request

    POST https://api.voiceit.io/enrollments/video/byUrl

    Request Parameters

    Parameter Type Description Required
    userId String The ID of the user True
    contentLanguage String Choose from a list of 88 content language parameters True
    fileUrl String A fully qualified url to the video file ( we recommend an mp4 formatted video file) True
    doBlinkDetection Boolean Is set to false by default ( to get the blinksCount from the JSON response, set to true. This may increase the processing time of the API call ) False

    SUCC, MISP, DDNE, IFVD, SRNR, SSTQ, SSTL, NEHSD, STTF, RWPU, FTMF, FNFD, and UNFD
    See detailed descriptions for response codes here

    Delete All Enrollments for User

    curl -u <apiKey>:<apiToken> -X DELETE "https://api.voiceit.io/enrollments/<userId>/all"
    
    my_voiceit.delete_all_enrollments_for_user("<userId>")
    
    myVoiceIt.deleteAllEnrollmentsForUser("<userId>");
    
    myVoiceIt.deleteAllEnrollmentsForUser("<userId>")
    
    myVoiceIt.DeleteAllEnrollmentsForUser("<userId>")
    
    myVoiceIt.deleteAllEnrollmentsForUser({
      userId : "<userId>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.DeleteAllEnrollmentsForUser("<userId>");
    
    <?php
    $myVoiceIt->deleteAllEnrollmentsForUser("<userId>");
    ?>
    
    $myVoiceIt->deleteAllEnrollmentsForUser("<userId>");
    
    myVoiceIt.DeleteAllEnrollmentsForUser("<userId>");
    
    myVoiceIt.deleteAllEnrollmentsForUser("<userId>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
    "message": "All enrollments for user with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322 were deleted",
    "responseCode": "SUCC",
    "status": 200,
    "timeTaken": "0.016s"
    }
    

    This endpoint deletes all registered enrollments for a given userId.

    HTTP Request

    DELETE https://api.voiceit.io/enrollments/<userId>/all

    URL Parameters

    Parameter Type Description Required
    userId String The ID of the user True

    SUCC, MISP, and UNFD See detailed descriptions for response codes here

    Delete Face Enrollment

    curl -u <apiKey>:<apiToken> -X DELETE "https://api.voiceit.io/enrollments/face/<userId>/<faceEnrollmentId>"
    
    my_voiceit.delete_face_enrollment("<userId>", <faceEnrollmentId>)
    
    myVoiceIt.deleteFaceEnrollment("<userId>", <faceEnrollmentId>);
    
    myVoiceIt.deleteFaceEnrollment("<userId>", <faceEnrollmentId>)
    
    myVoiceIt.DeleteFaceEnrollment("<userId>", <faceEnrollmentId>)
    
    myVoiceIt.deleteFaceEnrollment({
      userId : "<userId>",
      faceEnrollmentId : <faceEnrollmentId>
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.DeleteFaceEnrollment("<userId>", <faceEnrollmentId>);
    
    <?php
    $myVoiceIt->deleteFaceEnrollment("<userId>", <faceEnrollmentId>);
    ?>
    
    $myVoiceIt->deleteFaceEnrollment("<userId>", <faceEnrollmentId>);
    
    myVoiceIt.DeleteFaceEnrollment( "<userId>", <faceEnrollmentId>);
    
    myVoiceIt.deleteFaceEnrollment("<userId>", <faceEnrollmentId>, (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Deleted face enrollment with faceEnrollmentId : 35 for user with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322",
        "status": 200,
        "timeTaken": "0.057s",
        "responseCode" : "SUCC"
    }
    

    This endpoint deletes a specific face enrollment with the given faceEnrollmentId.

    HTTP Request

    DELETE https://api.voiceit.io/enrollments/face/<userId>/<faceEnrollmentId>

    URL Parameters

    Parameter Type Description Required
    userId String The ID of the user True
    faceEnrollmentId Integer The ID for the face enrollment to delete for the user True

    SUCC, MISP, ENFD, and UNFD
    See detailed descriptions for response codes here

    Delete Enrollment for User

    curl -u <apiKey>:<apiToken> -X DELETE "https://api.voiceit.io/enrollments/<userId>/<enrollmentId>"
    
    my_voiceit.delete_enrollment_for_user("<userId>", <enrollmentId>)
    
    myVoiceIt.deleteEnrollmentForUser("<userId>", <enrollmentId>);
    
    myVoiceIt.deleteEnrollmentForUser("<userId>", <enrollmentId>)
    
    myVoiceIt.DeleteEnrollmentForUser("<userId>", <enrollmentId>)
    
    myVoiceIt.deleteEnrollmentForUser({
      userId : "<userId>",
      enrollmentId : "<enrollmentId>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.DeleteEnrollmentForUser("<userId>", <enrollmentId>);
    
    <?php
    $myVoiceIt->deleteEnrollmentForUser("<userId>", <enrollmentId>);
    ?>
    
    $myVoiceIt->deleteEnrollmentForUser("<userId>", <enrollmentId>);
    
    myVoiceIt.DeleteEnrollmentForUser( "<userId>", <enrollmentId>);
    
    myVoiceIt.deleteEnrollmentForUser("<userId>", <enrollmentId>,  (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Deleted enrollment with id : 35 for user with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322",
        "status": 200,
        "timeTaken": "0.057s",
        "responseCode":"SUCC"
    }
    

    This endpoint deletes a specific enrollment with the given enrollmentId.

    HTTP Request

    DELETE https://api.voiceit.io/enrollments/<userId>/<enrollmentId>

    URL Parameters

    Parameter Type Description Required
    userId String The ID of the user True
    enrollmentId Integer The ID for the enrollment to delete for the user True

    SUCC, MISP, ENFD, and UNFD
    See detailed descriptions for response codes here

    Verification

    Verify a User's Voice

    curl -u <apiKey>:<apiToken> -X POST \
      -F "userId=<userId>" \
      -F "contentLanguage=<contentLanguage>" \
      -F "recording=@<recording>" \
      "https://api.voiceit.io/verification"
    
    my_voiceit.voice_verification("<userId>", "<contentLanguage>", "<recording>")
    
    myVoiceIt.voiceVerification("<userId>", "<contentLanguage>", "<recording>");
    
    myVoiceIt.voiceVerification("<userId>", "<contentLanguage>", "<recording>")
    
    myVoiceIt.VoiceVerification("<userId>", "<contentLanguage>", "<recording>")
    
    myVoiceIt.voiceVerification({
      userId : "<userId>",
      contentLanguage : "<contentLanguage>",
      audioFilePath : "<recording>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.VoiceVerification("<userId>", "<contentLanguage>", "<recording>");
    
    <?php
    $myVoiceIt->voiceVerification("<userId>", "<contentLanguage>", "<recording>");
    ?>
    
    $myVoiceIt->voiceVerification("<userId>", "<contentLanguage>", "<recording>");
    
    myVoiceIt.VoiceVerification("<userId>", "<contentLanguage>", "<recording>");
    
    myVoiceIt.voiceVerification("<userId>", "<contentLanguage>", "<recording>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Successfully verified voice for user with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322",
        "status": 200,
        "confidence": 94.0,
        "text": "never forget tomorrow is a new day",
        "textConfidence": 100,
        "timeTaken": "6.055s",
        "responseCode":"SUCC"
    }
    

    This endpoint verifies the voice of the user against a minimum of three (3) previous enrollments of the same phrase for the given userId

    HTTP Request

    POST https://api.voiceit.io/verification

    Request Parameters

    Parameter Type Description Required
    userId String The ID of the user True
    contentLanguage String Choose from a list of 88 content language parameters True
    recording File / String The binary audio data uploaded as a file. Our wrappers also accept the absolute path to the audio file ( we recommend a wav formatted audio file) True

    SUCC, FAIL, MISP, DDNE, IFAD, SRNR, SSTQ, SSTL, NEHSD, STTF, RWPU and UNFD
    See detailed descriptions for response codes here

    Verify a User's Voice by URL

    curl -u <apiKey>:<apiToken> -X POST \
      -F "userId=<userId>" \
      -F "contentLanguage=<contentLanguage>" \
      -F "fileUrl=<fileUrl>" \
      "https://api.voiceit.io/verification/byUrl"
    
    my_voiceit.voice_verification_by_url("<userId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.voiceVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.voiceVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.VoiceVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.voiceVerificationByUrl({
      userId : "<userId>",
      contentLanguage : "<contentLanguage>",
      audioFileURL : "<fileUrl>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.VoiceVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    <?php
    $myVoiceIt->voiceVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    ?>
    
    $myVoiceIt->voiceVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.VoiceVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.voiceVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Successfully verified voice for user with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322",
        "status": 200,
        "confidence": 94.0,
        "text": "never forget tomorrow is a new day",
        "textConfidence": 100,
        "timeTaken": "6.055s",
        "responseCode":"SUCC"
    }
    

    This endpoint verifies the voice of the user against a minimum of three (3) previous enrollments of the same phrase for the given userId

    HTTP Request

    POST https://api.voiceit.io/verification/byUrl

    Request Parameters

    Parameter Type Description Required
    userId String The ID of the user True
    contentLanguage String Choose from a list of 88 content language parameters True
    fileUrl String A fully qualified URL to the audio file to be used for voice verification True

    SUCC, FAIL, MISP, DDNE, IFAD, SRNR, SSTQ, SSTL, NEHSD, STTF, RWPU and UNFD
    See detailed descriptions for response codes here

    Verify a User's Face

    curl -u <apiKey>:<apiToken> -X POST \
      -F "userId=<userId>" \
      -F "video=@<video>" \
      "https://api.voiceit.io/verification/face"
    
    my_voiceit.face_verification("<userId>", "<video>")
    
    myVoiceIt.faceVerification("<userId>", "<video>");
    
    myVoiceIt.faceVerification("<userId>", "<video>")
    
    myVoiceIt.FaceVerification("<userId>", "<video>")
    
    myVoiceIt.faceVerification({
      userId : "<userId>",
      videoFilePath : "<video>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.FaceVerification("<userId>", "<video>");
    
    <?php
    $myVoiceIt->faceVerification("<userId>", "<video>");
    ?>
    
    $myVoiceIt->faceVerification("<userId>", "<video>");
    
    myVoiceIt.FaceVerification("<userId>", "<video>");
    
    myVoiceIt.faceVerification("<userId>", "<video>", false, (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Successfully verified face for user with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322",
        "status": 200,
        "faceConfidence": 94.0,
        "blinksCount": 0,
        "timeTaken": "6.055s",
        "responseCode":"SUCC"
    }
    

    This endpoint verifies the face of the user against previous enrollments for the given userId

    HTTP Request

    POST https://api.voiceit.io/verification/face

    Request Parameters

    Parameter Type Description Required
    userId String The ID of the user True
    video File / String The binary video data uploaded as a file. Our wrappers also accept the absolute path to the video file ( we recommend an mp4 formatted video) True
    doBlinkDetection Boolean Is set to false by default ( In order to get the blinksCount from the JSON response, set to true. This may increase the processing time of the API call ) False

    SUCC, FAIL, MISP, FNFD, FTMF, UNFD
    See detailed descriptions for response codes here

    Video Verification

    curl -u <apiKey>:<apiToken> -X POST \
      -F "userId=<userId>" \
      -F "contentLanguage=<contentLanguage>" \
      -F "video=@<video>" \
      "https://api.voiceit.io/verification/video"
    
    my_voiceit.video_verification("<userId>", "<contentLanguage>", "<video>")
    
    myVoiceIt.videoVerification("<userId>", "<contentLanguage>", "<video>");
    
    myVoiceIt.videoVerification("<userId>", "<contentLanguage>", "<video>")
    
    myVoiceIt.VideoVerification("<userId>", "<contentLanguage>", "<video>")
    
    myVoiceIt.videoVerification({
      userId : "<userId>",
      contentLanguage : "<contentLanguage>",
      videoFilePath : "<video>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.VideoVerification("<userId>", "<contentLanguage>", "<video>");
    
    <?php
    $myVoiceIt->videoVerification("<userId>", "<contentLanguage>", "<video>");
    ?>
    
    $myVoiceIt->videoVerification("<userId>", "<contentLanguage>", "<video>");
    
    myVoiceIt.VideoVerification("<userId>", "<contentLanguage>", "<video>", true);
    
    myVoiceIt.videoVerification("<userId>", "<contentLanguage>", "<video>", false, (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Successfully verified video user with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322",
        "status": 200,
        "voiceConfidence": 93.00,
        "faceConfidence": 94.0,
        "text" : "never forget tomorrow is a new day",
        "textConfidence" : 100.00,
        "blinksCount": 2,
        "timeTaken": "8.055s",
        "responseCode":"SUCC"
    }
    

    This endpoint verifies the face and voice of the user against a minimum of three (3) previous enrollments of the same phrase for the given userId

    HTTP Request

    POST https://api.voiceit.io/verification/video

    Request Parameters

    Parameter Type Description Required
    userId String The ID of the user True
    contentLanguage String Choose from a list of 88 content language parameters True
    video File / String The binary video data uploaded as a file. Our wrappers also accept the absolute path to the video file ( we recommend an mp4 formatted video) True
    doBlinkDetection Boolean Is set to false by default ( In order to get the blinksCount from the JSON response, set to true. This may increase the processing time of the API call ) False

    SUCC, FAIL, MISP, DDNE, IFVD, SRNR, SSTQ, SSTL, NEHSD, STTF, RWPU, FTMF, FNFD and GNFD
    See detailed descriptions for response codes here

    Video Verification by URL

    curl -u <apiKey>:<apiToken> -X POST \
      -F "userId=<userId>" \
      -F "contentLanguage=<contentLanguage>" \
      -F "fileUrl=<fileUrl>" \
      "https://api.voiceit.io/verification/video/byUrl"
    
    my_voiceit.video_verification_by_url("<userId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.videoVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.videoVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.VideoVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.videoVerificationByUrl({
      userId : "<userId>",
      contentLanguage : "<contentLanguage>",
      videoFileURL : "<fileUrl>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.VideoVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    <?php
    $myVoiceIt->videoVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    ?>
    
    $myVoiceIt->videoVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.VideoVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.videoVerificationByUrl("<userId>", "<contentLanguage>", "<fileUrl>", false, (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Successfully verified video user with userId : usr_feb6d1fcd80448628db8ec6a7ddb6322",
        "status": 200,
        "voiceConfidence": 93.00,
        "faceConfidence": 94.0,
        "text" : "never forget tomorrow is a new day",
        "textConfidence" : 100.00,
        "blinksCount": 2,
        "timeTaken": "8.055s",
        "responseCode":"SUCC"
    }
    

    This endpoint verifies the face and voice of the user against a minimum of three (3) previous enrollments of the same phrase for the given userId

    HTTP Request

    POST https://api.voiceit.io/verification/video/byUrl

    Request Parameters

    Parameter Type Description Required
    userId String The ID of the user True
    contentLanguage String Choose from a list of 88 content language parameters True
    fileUrl String A fully qualified url to the video file ( we recommend an mp4 formatted video file) True
    doBlinkDetection Boolean Is set to false by default ( In order to get the blinksCount from the JSON response, set to true. This may increase the processing time of the API call ) False

    SUCC, FAIL, MISP, DDNE, IFVD, SRNR, SSTQ, SSTL, NEHSD, STTF, RWPU, FTMF, FNFD and GNFD
    See detailed descriptions for response codes here

    Identification

    Identify a User's Voice

    curl -u <apiKey>:<apiToken> -X POST \
      -F "groupId=<groupId>" \
      -F "contentLanguage=<contentLanguage>" \
      -F "recording=@<recording>" \
      "https://api.voiceit.io/identification"
    
    my_voiceit.voice_identification("<groupId>", "<contentLanguage>", "<recording>")
    
    myVoiceIt.voiceIdentification("<groupId>", "<contentLanguage>", <recording>);
    
    myVoiceIt.voiceIdentification("<groupId>", "<contentLanguage>", "<recording>")
    
    myVoiceIt.VoiceIdentification("<groupId>", "<contentLanguage>", "<recording>")
    
    myVoiceIt.voiceIdentification({
      groupId : "<groupId>",
      contentLanguage : "<contentLanguage>",
      audioFilePath : "<recording>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.VoiceIdentification("<groupId>", "<contentLanguage>", "<recording>");
    
    <?php
    $myVoiceIt->voiceIdentification("<groupId>", "<contentLanguage>", "<recording>");
    ?>
    
    $myVoiceIt->voiceIdentification("<groupId>", "<contentLanguage>", "<recording>");
    
    myVoiceIt.VoiceIdentification("<groupId>", "<contentLanguage>", "<recording>");
    
    myVoiceIt.voiceIdentification("<groupId>", "<contentLanguage>", "<recording>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Successfully identified voice for user with userId : usr_49c98304252549239775e2b52a84006a in group with groupId : grp_801e4d6dc1e941bf9165ba5c84bd94d2",
        "userId": "usr_49c98304252549239775e2b52a84006a",
        "groupId": "grp_801e4d6dc1e941bf9165ba5c84bd94d2",
        "confidence": 96.00,
        "status": 200,
        "text": "never forget tomorrow is a new day",
        "textConfidence": 100.00,
        "timeTaken": "9.969s",
        "responseCode":"SUCC"
    }
    

    This endpoint identifies the voice of the user amongst other users in the group for the given groupId

    HTTP Request

    POST https://api.voiceit.io/identification

    Request Parameters

    Parameter Type Description Required
    groupId String The ID of the group True
    contentLanguage String Choose from a list of 88 content language parameters True
    recording File / String The binary audio data uploaded as a file. Our wrappers also accept the absolute path to the audio file ( we recommend a wav formatted audio file) True

    SUCC, FAIL, MISP, DDNE, IFAD, SRNR, SSTQ, SSTL, NEHSD, STTF, RWPU and GNFD
    See detailed descriptions for response codes here

    Identify a User's Voice by URL

    curl -u <apiKey>:<apiToken> -X POST \
      -F "groupId=<groupId>" \
      -F "contentLanguage=<contentLanguage>" \
      -F "fileUrl=<fileUrl>" \
      "https://api.voiceit.io/identification/byUrl"
    
    my_voiceit.voice_identification_by_url("<groupId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.voiceIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.voiceIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.VoiceIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.voiceIdentificationByUrl({
      groupId : "<groupId>",
      contentLanguage : "<contentLanguage>",
      audioFileURL : "<fileUrl>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.VoiceIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>");
    
    <?php
    $myVoiceIt->voiceIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>");
    ?>
    
    $myVoiceIt->voiceIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.VoiceIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.voiceIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>", (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Successfully identified voice for user with userId : usr_49c98304252549239775e2b52a84006a in group with groupId : grp_801e4d6dc1e941bf9165ba5c84bd94d2",
        "userId": "usr_49c98304252549239775e2b52a84006a",
        "groupId": "grp_801e4d6dc1e941bf9165ba5c84bd94d2",
        "confidence": 96.00,
        "status": 200,
        "text": "never forget tomorrow is a new day",
        "textConfidence": 100.00,
        "timeTaken": "9.969s",
        "responseCode":"SUCC"
    }
    

    This endpoint identifies the voice of the user amongst other users in the group for the given groupId

    HTTP Request

    POST https://api.voiceit.io/identification/byUrl

    Request Parameters

    Parameter Type Description Required
    groupId String The ID of the group True
    contentLanguage String Choose from a list of 88 content language parameters True
    fileUrl String A fully qualified URL to the audio file to be used for voice verification True

    SUCC, FAIL, MISP, DDNE, IFAD, SRNR, SSTQ, SSTL, NEHSD, STTF, RWPU and GNFD
    See detailed descriptions for response codes here

    Video Identification

    curl -u <apiKey>:<apiToken> -X POST \
      -F "groupId=<groupId>" \
      -F "contentLanguage=<contentLanguage>" \
      -F "video=@<video>" \
      "https://api.voiceit.io/identification/video"
    
    my_voiceit.video_identification("<groupId>", "<contentLanguage>", "<video>")
    
    myVoiceIt.videoIdentification("<groupId>", "<contentLanguage>", "<video>");
    
    myVoiceIt.videoIdentification("<groupId>", "<contentLanguage>", "<video>")
    
    myVoiceIt.VideoIdentification("<groupId>", "<contentLanguage>", "<video>")
    
    myVoiceIt.videoIdentification({
      groupId : "<groupId>",
      contentLanguage : "<contentLanguage>",
      videoFilePath : "<video>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.VideoIdentification("<groupId>", "<contentLanguage>", "<video>");
    
    <?php
    $myVoiceIt->videoIdentification("<groupId>", "<contentLanguage>", "<video>");
    ?>
    
    $myVoiceIt->videoIdentification("<groupId>", "<contentLanguage>", "<video>");
    
    myVoiceIt.VideoIdentification("<groupId>", "<contentLanguage>", "<video>");
    
    myVoiceIt.videoIdentification("<groupId>", "<contentLanguage>", "<video>", false, (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Successfully identified video for user with userId : usr_49c98304252549239775e2b52a84006a in group with groupId : grp_801e4d6dc1e941bf9165ba5c84bd94d2",
        "userId": "usr_49c98304252549239775e2b52a84006a",
        "groupId": "grp_801e4d6dc1e941bf9165ba5c84bd94d2",
        "status": 200,
        "voiceConfidence": 93.00,
        "faceConfidence": 94.0,
        "text" : "never forget tomorrow is a new day",
        "textConfidence" : 100.00,
        "blinksCount": 2,
        "timeTaken": "8.055s",
        "responseCode":"SUCC"
    }
    

    This endpoint identifies the face and voice of the user amongst other users in the group for the given groupId

    HTTP Request

    POST https://api.voiceit.io/identification/video

    Request Parameters

    Parameter Type Description Required
    groupId String The ID of the group True
    contentLanguage String Choose from a list of 88 content language parameters True
    video File / String The binary video data uploaded as a file. Our wrappers accept the absolute path to the video file ( we recommend an mp4 formatted video) True
    doBlinkDetection Boolean Is set to false by default ( In order to get the blinksCount from the JSON response, set to true. This may increase the processing time of the API call ) False

    SUCC, FAIL, MISP, DDNE, IFVD, SRNR, SSTQ, SSTL, NEHSD, STTF, RWPU, FTMF, FNFD and GNFD
    See detailed descriptions for response codes here

    Video Identification by URL

    curl -u <apiKey>:<apiToken> -X POST \
      -F "groupId=<groupId>" \
      -F "contentLanguage=<contentLanguage>" \
      -F "fileUrl=<fileUrl>" \
      "https://api.voiceit.io/identification/video/byUrl"
    
    my_voiceit.video_identification_by_url("<groupId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.videoIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.videoIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.VideoIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>")
    
    myVoiceIt.videoIdentificationByUrl({
      groupId : "<groupId>",
      contentLanguage : "<contentLanguage>",
      videoFileURL : "<fileUrl>"
    },(jsonResponse)=>{
      //handle response
    });
    
    myVoiceIt.VideoIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>");
    
    <?php
    $myVoiceIt->videoIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>");
    ?>
    
    $myVoiceIt->videoIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.VideoIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>");
    
    myVoiceIt.videoIdentificationByUrl("<groupId>", "<contentLanguage>", "<fileUrl>", false, (jsonResponse : String) => {
      // Parse jsonResponse
    })
    

    The above command returns JSON structured like this:

    {
        "message": "Successfully identified video for user with userId : usr_49c98304252549239775e2b52a84006a in group with groupId : grp_801e4d6dc1e941bf9165ba5c84bd94d2",
        "userId": "usr_49c98304252549239775e2b52a84006a",
        "groupId": "grp_801e4d6dc1e941bf9165ba5c84bd94d2",
        "status": 200,
        "voiceConfidence": 93.00,
        "faceConfidence": 94.0,
        "text" : "never forget tomorrow is a new day",
        "textConfidence" : 100.00,
        "blinksCount": 2,
        "timeTaken": "8.055s",
        "responseCode":"SUCC"
    }
    

    This endpoint identifies the face and voice of the user amongst other users in the group for the given groupId

    HTTP Request

    POST https://api.voiceit.io/identification/video/byUrl

    Request Parameters

    Parameter Type Description Required
    groupId String The ID of the group True
    contentLanguage String Choose from a list of 88 content language parameters True
    fileUrl String A fully qualified url to the video file ( we recommend an mp4 formatted video file) True
    doBlinkDetection Boolean Is set to false by default ( In order to get the blinksCount from the JSON response, set to true. This may increase the processing time of the API call ) False

    SUCC, FAIL, MISP, DDNE, IFVD, SRNR, SSTQ, SSTL, NEHSD, STTF, RWPU, FTMF, FNFD and GNFD
    See detailed descriptions for response codes here

    Content Languages

    The VoiceIt Voice and Video Enrollment/Verification/Identification API calls allow you to pass any of the following 88 supported content language parameters:

    Languages without an upcharge

    Content Language Language
    Catalan (Spain)ca-ES
    Chinese, Mandarin (Simplified, China)cmn-Hans-CN
    Chinese, Mandarin (Simplified, Hong Kong)cmn-Hans-HK
    Chinese, Mandarin (Traditional, Taiwan)cmn-Hant-TW
    Danish (Denmark)da-DK
    German (Germany)de-DE
    English (Australia)en-AU
    English (Canada)en-CA
    English (United Kingdom)en-GB
    English (United States)en-US
    Spanish (Spain)es-ES
    Spanish (Mexico)es-MX
    Spanish (United States)es-US
    Finnish (Finland)fi-FI
    French (Canada)fr-CA
    French (France)fr-FR
    Japanese (Japan)ja-JP
    Korean (South Korea)ko-KR
    Norwegian Bokmal (Norway)nb-NO
    Dutch (Netherlands)nl-NL
    No Speech To Textno-STT
    Polish (Poland)pl-PL
    Portuguese (Brazil)pt-BR
    Portuguese (Portugal)pt-PT
    Russian (Russia)ru-RU
    Swedish (Sweden)sv-SE

    Premium Languages with an upcharge($0.006)

    Content Language Language
    Afrikaans (South Africa)af-ZA
    Amharic (Ethiopia)am-ET
    Arabic (United Arab Emirates)ar-AE
    Arabic (Bahrain)ar-BH
    Arabic (Algeria)ar-DZ
    Arabic (Egypt)ar-EG
    Arabic (Israel)ar-IL
    Arabic (Iraq)ar-IQ
    Arabic (Jordan)ar-JO
    Arabic (Kuwait)ar-KW
    Arabic (Lebanon)ar-LB
    Arabic (Morocco)ar-MA
    Arabic (Oman)ar-OM
    Arabic (State of Palestine)ar-PS
    Arabic (Qatar)ar-QA
    Arabic (Saudi Arabia)ar-SA
    Arabic (Tunisia)ar-TN
    Azerbaijani (Azerbaijan)az-AZ
    Bulgarian (Bulgaria)bg-BG
    Bengali (Bangladesh)bn-BD
    Bengali (India)bn-IN
    Czech (Czech Republic)cs-CZ
    Greek (Greece)el-GR
    English (Ghana)en-GH
    English (Ireland)en-IE
    English (India)en-IN
    English (Kenya)en-KE
    English (Nigeria)en-NG
    English (New Zealand)en-NZ
    English (Philippines)en-PH
    English (Tanzania)en-TZ
    English (South Africa)en-ZA
    Spanish (Argentina)es-AR
    Spanish (Bolivia)es-BO
    Spanish (Chile)es-CL
    Spanish (Colombia)es-CO
    Spanish (Costa Rica)es-CR
    Spanish (Dominican Republic)es-DO
    Spanish (Ecuador)es-EC
    Spanish (Guatemala)es-GT
    Spanish (Honduras)es-HN
    Spanish (Nicaragua)es-NI
    Spanish (Panama)es-PA
    Spanish (Peru)es-PE
    Spanish (Puerto Rico)es-PR
    Spanish (Paraguay)es-PY
    Spanish (El Salvador)es-SV
    Spanish (Uruguay)es-UY
    Spanish (Venezuela)es-VE
    Basque (Spain)eu-ES
    Persian (Iran)fa-IR
    Filipino (Philippines)fil-PH
    Galician (Spain)gl-ES
    Gujarati (India)gu-IN
    Hebrew (Israel)he-IL
    Hindi (India)hi-IN
    Croatian (Croatia)hr-HR
    Hungarian (Hungary)hu-HU
    Armenian (Armenia)hy-AM
    Indonesian (Indonesia)id-ID
    Icelandic (Iceland)is-IS
    Italian (Italy)it-IT
    Javanese (Indonesia)jv-ID
    Georgian (Georgia)ka-GE
    Khmer (Cambodia)km-KH
    Kannada (India)kn-IN
    Lao (Laos)lo-LA
    Lithuanian (Lithuania)lt-LT
    Latvian (Latvia)lv-LV
    Malayalam (India)ml-IN
    Marathi (India)mr-IN
    Malay (Malaysia)ms-MY
    Nepali (Nepal)ne-NP
    Romanian (Romania)ro-RO
    Sinhala (Sri Lanka)si-LK
    Slovak (Slovakia)sk-SK
    Slovenian (Slovenia)sl-SI
    Serbian (Serbia)sr-RS
    Sundanese (Indonesia)su-ID
    Swahili (Kenya)sw-KE
    Swahili (Tanzania)sw-TZ
    Tamil (India)ta-IN
    Tamil (Sri Lanka)ta-LK
    Tamil (Malaysia)ta-MY
    Tamil (Singapore)ta-SG
    Telugu (India)te-IN
    Thai (Thailand)th-TH
    Turkish (Turkey)tr-TR
    Ukrainian (Ukraine)uk-UA
    Urdu (India)ur-IN
    Urdu (Pakistan)ur-PK
    Vietnamese (Vietnam)vi-VN
    Chinese, Cantonese (Traditional, Hong Kong)yue-Hant-HK
    Zulu (South Africa)zu-ZA

    Response Codes

    The VoiceIt Face Verification API uses the following response codes:

    Response Code Meaning
    SUCC Successful API call
    MISP Missing parameters
    MISU Missing users
    FAIL The API call failed
    UNFD User not found
    GNFD Group not found
    ENFD Enrollment not found
    FNFD Face not found
    DDNE Data does not exist
    FNFD Face not found in video
    FTMF Found too many faces in video
    IFAD Incorrect formatted audio data
    IFVD Incorrect formatted video data
    INCP Incorrect contentLanguage parameter
    SRNR Sound recording does not meet requirements
    SSTQ Speaker is speaking too quiet
    SSTL Speaker is speaking too loud
    NEHSD No human speech detected
    STTF Speech to text failed
    RWPU Recording was previously used
    PNTE Phrase needs a minimum of three enrollments
    TVER Three video enrollments required
    NFEF No face enrollments found
    GERR A general error occurred
    DAID Developer account is disabled ( most likely due to insufficient funds)
    UNAC Unauthorized access ( make sure you are using the right API Key and Token)
    CLNE Content language not enabled for free tier, only en-US is available on the VoiceIt free tier plan
    ACLR API Call Limit Reached

    Errors

    The VoiceIt Face Verification API uses the following error codes:

    Error Code Meaning
    400 Bad Request -- Something is wrong with your request.
    401 Unauthorized -- Your API key is wrong.
    404 Not Found -- The user could not be found.
    405 Method Not Allowed -- You tried to access VoiceIt with an invalid method.
    500 Internal Server Error -- We had a problem with our server. Try again later.
    503 Service Unavailable -- We're temporarily offline for maintenance. Please try again later.
    }