Introduction

Welcome to intervue.io API Docs! You can use our API to access our endpoints, which can help you automate your workflow.

Authentication

echo 'accessToken:secretKey' | base64

import base64
ENCODED_KEY = base64.b64encode(b'accessToken:secretKey')

let ENCODED_KEY = Buffer.from("accessToken:secretKey").toString("base64");

// java.util.Base64

String ENCODED_KEY = new String(Base64.getEncoder().encode("accessToken:secretKey".getBytes()));

# With shell, you can just pass the correct header with each request
curl "https://api.intervue.io/health" \
  -H "Authorization: Basic <ENCODED_KEY>"

import requests
import json

url = "https://api.intervue.io/health"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers)

print(response.text)

const config = {
  method: "post",
  url: "https://api.intervue.io/health",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
Request request = new Request.Builder()
  .url("https://api.intervue.io/health")
  .method("POST")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

intervue.io uses API keys to allow access to the API.

To generate API Key

Log into your intervue.io account
Go to settings page
Click "Developer settings" tab
Click "Generate API key"
Copy the Access token and Secret key

This will generate Access token and Secret key, which you can use to create auth header for the API requests.

intervue.io expects the API key to be included in all API requests to the server in a header in the following format: Authorization: Basic <ENCODED_KEY>

You must replace <ENCODED_KEY> with base64("accessToken:secretKey").

Rate limiting

intervue.io rate limits the incoming requests and send the following headers

Header	Description
RateLimit-Limit	the server's quota for requests by the client in the time window
RateLimit-Remaining	the remaining quota in the current window
RateLimit-Reset	the time remaining in the current window, specified in seconds
Retry-After	the time remaining in seconds after which user can retry, sent to all blocked requests, specified in seconds

Only 50 requests are allowed per minute per API key

External Interviews

Schedule external interview

curl --location --request POST 'https://api.intervue.io/external-interviews/request' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \
--data-raw '{
  "candidates": [{
    "name": "Candidate name",
    "email": "Candidate email",
    "phoneNo": "Candidate phoneNo"
  }],
  "hiringRoleId": 9999,
}'

import requests
import json

url = "https://api.intervue.io/external-interviews/request"

payload = json.dumps({
  "candidates": [{
    "name": "Candidate name",
    "email": "Candidate email",
    "phoneNo": "Candidate phoneNo"
  }],
  "hiringRoleId": 9999,
})
headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

const axios = require("axios");
const data = JSON.stringify({
  candidate: [
    {
      name: "Candidate name",
      email: "Candidate email",
      phoneNo: "candidate phoneNo",
    },
  ],
  hiringRoleId: 9999,
});

const config = {
  method: "post",
  url: "https://api.intervue.io/external-interviews/request",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
  data: data,
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType,"{\"candidates\":[{\"name\":\"candidate name\",\"email\":\"candidate email\",\"phoneNo\":\"candidate phoneNo\"}],\"hiringRoleId\":9999}");
Request request = new Request.Builder()
  .url("https://api.intervue-dev.io/external-interviews/request")
  .method("POST", body)
  .addHeader("Authorization", "Basic amFqYWphamE6YmFiYWJhYmE=")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "message": "On-demand request(s) has been initiated",
  "data": [
    {
      "name": "Candidate name",
      "email": "Candidate email",
      "phoneNo": "Candidate phoneNo",
      "interviewId": "interview uuid"
    }
  ]
}

Request an external interview for one or more candidates

HTTP Request

POST https://api.intervue.io/external-interviews/request

Body Parameters

Parameter	Type	Required	Description
candidates	Array of candidate objects	true	array of candidates
hiringRoleId	integer	true	hiring role id

Candidate object for upload

Parameter	Type	Required	Description
name	string	true	candidate name
email	string	true	candidate email
phoneNo	string	true	candidate phone number
resume	object	false	resume object
timeSlots	object	false	array of timeslots
utcOffset	number	false	the UTC timezone offset of the timeslots Default: `-330`

Resume object

Parameter	Type	Required	Description
fileName	string	true	resume file name
url	string	true	public resume url

Timeslot object

Parameter	Type	Required	Description
startTime	string	true	starting time for availability in ISO string format Timing should be between `10:00 AM` and `8:00 PM`
endTime	string	true	ending time for availability in ISO string format Timing should be between `11:00 AM` and `9:00 PM`

Update external interview

curl --location --request POST 'https://api.intervue.io/external-interviews/update' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \
--data-raw '{
  "candidate": {
    "name": "Candidate name",
    "email": "Candidate email",
    "phoneNo": "Candidate phoneNo"
  },
  "hiringRoleId": 9999,
  "interviewId": "interview uuid"
}'

import requests
import json

url = "https://api.intervue.io/external-interviews/update"

payload = json.dumps({
  "candidate": {
    "name": "Candidate name",
    "email": "Candidate email",
    "phoneNo": "Candidate phoneNo"
  },
  "hiringRoleId": 9999,
  "interviewId": "interview uuid"
})
headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

const axios = require("axios");
const data = JSON.stringify({
  candidate: {
    name: "Candidate name",
    email: "Candidate email",
    phoneNo: "Candidate phoneNo",
  },
  hiringRoleId: 9999,
  interviewId: "interview uuid",
});

const config = {
  method: "post",
  url: "https://api.intervue.io/external-interviews/update",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
  data: data,
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType,"{\"candidate\":{\"name\":\"candidate name\",\"email\":\"candidate email\",\"phoneNo\":\"candidate phoneNo\"},\"hiringRoleId\":9999,\"interviewId\":\"interview uuid\"}");
Request request = new Request.Builder()
  .url("https://api.intervue.io/external-interviews/update")
  .method("POST", body)
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "message": "On-demand request has been edited"
}

Update an external interview

HTTP Request

POST https://api.intervue.io/external-interviews/update

Body Parameters

Parameter	Type	Required	Description
interviewId	uuid(string)	true	id associated with the particular interview
candidate	candidate object	true	candidate object
hiringRoleId	integer	true	hiring role id

Candidate object for upload

Parameter	Type	Required	Description
name	string	true	candidate name
email	string	true	candidate email
phoneNo	string	true	candidate phone number
resume	resume object	false	resume object

Resume object

Parameter	Type	Required	Description
fileName	string	true	resume file name
url	string	true	public resume url

Cancel external interview

curl --location --request POST 'https://api.intervue.io/external-interviews/cancel' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \
--data-raw '{ "interviewId": "interview uuid" }'

import requests
import json

url = "https://api.intervue.io/external-interviews/cancel"

payload = json.dumps({ "interviewId": "interview uuid" })
headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

const axios = require("axios");
const data = JSON.stringify({ interviewId: "interview uuid" });

const config = {
  method: "post",
  url: "https://api.intervue.io/external-interviews/cancel",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
  data: data,
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"interviewId\":\"interview uuid\"}");
Request request = new Request.Builder()
  .url("https://api.intervue.io/external-interviews/cancel")
  .method("POST", body)
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "message": "On-demand interview canceled successfully"
}

Cancel an external interview

HTTP Request

POST https://api.intervue.io/external-interviews/cancel

Body Parameters

Parameter	Type	Required	Description
interviewId	uuid(string)	true	id associated with the particular interview

Get interview details

curl --location --request GET 'https://api.intervue.io/external-interviews/{ID}' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/external-interviews/{ID}"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/external-interviews/{ID}",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/external-interviews/{ID}")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "data": {
    "id": "bb1733c3-a57e-4f14-a0dd-8dffd78e4c38",
    "hiringRoleId": 9999,
    "roundName": "Core Android",
    "requestedAt": "2022-12-24T13:40:27.061Z",
    "requestedBy": {
      "name": "user name",
      "email": "user@email.com"
    },
    "scheduleDateTime": "2022-12-24T13:30:58.460Z",
    "candidate": {
      "name": "candidate name",
      "email": "candidate email",
      "phoneNo": "candidate phone number"
    }
  }
}

Get all the information regarding an interview

HTTP Request

GET https://api.intervue.io/external-interviews/{ID}

Path Parameters

Parameter	Type	Required	Description
interviewId	string(uuid)	true	unique id of interview in UUIDv4 format

Get hiring roles

curl --location --request GET 'https://api.intervue.io/external-interviews/getRoles' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/external-interviews/getRoles"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/external-interviews/getRoles",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/external-interviews/getRoles")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "data": [
    {
      "id": 9999,
      "internalName": "Name",
      "jobTitle": "Title",
      "seniority": "Internship",
      "candidateProfile": "FRONTEND",
      "workplaceModel": "WORK_FROM_OFFICE",
      "enabledRounds": ["round 1", "round 2"],
      "engineeringTeamSize": "SMALL",
      "ctc": null,
    }
  ],
  "pageNumber": 1,
  "pageSize": 10,
  "next": false,
  "totalResults": 1
}

Get all the hiring roles for your organisation

HTTP Request

GET https://api.intervue.io/external-interviews/getRoles

Query Parameters

Parameter	Type	Required	Description
pageNumber	integer	false	the page number to get result of `>=1` Default: `1`
pageSize	integer	false	the number of rows to return at a time `>=1` Default: `10`
candidateProfile	string	false	filter hiring roles based on a specific candidate profile
getTotal	boolean	false	get total result count irrespective of published status
includeDraftCount	boolean	false	whether to include count for hiring roles with published status as Draft
sortBy	string	false	order results by the specified field Allowed values: `createdAt` else defaults to `createdAt`
sortedByDirection	string	false	order results in the direction of the specified field Allowed values: `ASC`, `DESC` else defaults to `DESC`

Get hiring role by ID

curl --location --request GET 'https://api.intervue.io/external-interviews/getRole/roleId' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/external-interviews/getRole/roleId"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/external-interviews/getRole/roleId",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/external-interviews/getRole/roleId")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "data": {
    "id": 9999,
    "internalName": "Frontend",
    "jobTitle": "Frontend Engineer",
    "jdLink": null,
    "jdFileName": null,
    "seniority": "Mid-senior",
    "workplaceModel": "HYBRID",
    "engineeringTeamSize": "MEDIUM",
    "ctc": "10+ LPA",
    "candidateProfile": "FRONTEND",
    "publishStatus": "LIVE"
  }
}

Get a particular hiring role

HTTP Request

GET https://api.intervue.io/external-interviews/getRole/{roleId}

Path Parameters

Parameter	Type	Required	Description
roleId	integer	true	the role ID to get response of

Get rounds

curl --location --request GET 'https://api.intervue.io/external-interviews/getRounds/profile' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/external-interviews/getRounds/profile"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/external-interviews/getRounds/profile",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/external-interviews/getRounds/profile")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "data": [
    {
      "id": 31,
      "name": "Browser knowledge - Developer tools, REST APIs & Debugging",
      "description": "REST APIs type, Headers & significance, memory leaks, DOM, developer console",
      "skill": null,
      "profile": "FRONTEND",
      "seniorityList": ["Mid-senior", "Senior", "Senior-plus", "Staff"],
      "round": "Core Frontend Round"
    }
  ],
  "pageNumber": 1,
  "pageSize": 1,
  "next": true,
  "totalResults": 75
}

Get all the rounds and the rubrics supported for a profile

HTTP Request

GET https://api.intervue.io/external-interviews/getRounds/{profile}

Path Parameters

Parameter	Type	Required	Description
profile	string	true	the profile for which to get the rounds of

Query Parameters

Parameter	Type	Required	Description
pageNumber	integer	false	the page number to get result of `>=1` Default: `1`
pageSize	integer	false	the number of rows to return at a time `>=1` Default: `10`

Get round by ID

curl --location --request GET 'https://api.intervue.io/external-interviews/getRound/roundId' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/external-interviews/getRound/roundId"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/external-interviews/getRound/roundId",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/external-interviews/getRound/roundId")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "data": {
    "id": 32,
    "name": "Browser knowledge - Browser storage",
    "description": "Local storage, Session storage, Cookies, Cache etc.",
    "skill": null,
    "profile": "FRONTEND",
    "seniorityList": [
      "Mid-senior",
      "Senior",
      "Senior-plus",
      "Internship",
      "Entry-level",
      "Intermediate",
      "Staff"
    ],
    "round": "Core Frontend Round"
  }
}

Get rubrics for a particular round

HTTP Request

GET https://api.intervue.io/external-interviews/getRound/{roundId}

Path Parameters

Parameter	Type	Required	Description
roundId	integer	true	the round ID to get response of

Get all profiles

curl --location --request GET 'https://api.intervue.io/external-interviews/getProfiles' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/external-interviews/getProfiles"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/external-interviews/getProfiles",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/external-interviews/getProfiles")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "data": [
    {
      "value": "FRONTEND",
      "heading": "Frontend",
      "subHeading": "Eg. React, HTML, Angular, Vue, CSS, Javascript",
      "skills": [
        "Data Structure & Algorithms",
        "System design",
        "JavaScript",
        "React JS",
        "Angular JS",
        "Vue JS",
        "HTML/CSS",
        "Browser knowledge",
        "TypeScript",
        "Node JS"
      ],
      "rounds": [
        "Data Structure & Algorithms",
        "Frontend Fundamentals",
        "Libraries & Frameworks",
        "Coding",
        "Design"
      ]
    }
  ]
}

Get all the supported profiles on Intervue

HTTP Request

GET https://api.intervue.io/external-interviews/getProfiles

Mock Interviews

Schedule mock interview

curl --location --request POST 'https://api.intervue.io/mock-interviews/request' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \
--data-raw '{
  "candidates": [{
    "name": "Candidate name",
    "email": "Candidate email",
    "phoneNo": "Candidate phoneNo",
    "scheduleTime": ["2022-12-22T05:43:18.294Z", "2022-12-22T06:43:18.294Z"]
  }],
  "hiringRoleId": 9999,
}'

import requests
import json

url = "https://api.intervue.io/mock-interviews/request"

payload = json.dumps({
  "candidates": [{
    "name": "Candidate name",
    "email": "Candidate email",
    "phoneNo": "Candidate phoneNo"
  }],
  "hiringRoleId": 9999,
})
headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

const axios = require("axios");
const data = JSON.stringify({
  candidates: [
    {
      name: "Candidate name",
      email: "Candidate email",
      phoneNo: "candidate phoneNo",
      scheduleTime: ["2022-12-22T05:43:18.294Z", "2022-12-22T06:43:18.294Z"],
    },
  ],
  hiringRoleId: 9999,
});

const config = {
  method: "post",
  url: "https://api.intervue.io/mock-interviews/request",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
  data: data,
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType,"{\"candidates\":[{\"name\":\"candidate name\",\"email\":\"candidate email\",\"phoneNo\":\"candidate phoneNo\",\"scheduleTime\": [\"2022-12-22T05:43:18.294Z\",\"2022-12-22T06:43:18.294Z\"]}],\"hiringRoleId\":9999}");
Request request = new Request.Builder()
  .url("https://api.intervue-dev.io/mock-interviews/request")
  .method("POST", body)
  .addHeader("Authorization", "Basic amFqYWphamE6YmFiYWJhYmE=")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "message": "Mock interview request has been initiated",
  "data": [
    {
      "name": "Candidate name",
      "email": "Candidate email",
      "phoneNo": "1234567890",
      "interviewId": "d9f17bef-7164-4917-bb4c-fd62c476f8dd"
    }
  ]
}

Request a mock interview for one or more candidates

HTTP Request

POST https://api.intervue.io/mock-interviews/request

Body Parameters

Parameter	Type	Required	Description
candidates	Array of candidate objects	true	array of candidates
hiringRoleId	integer	true	hiring role id

Candidate object for upload

Parameter	Type	Required	Description
name	string	true	candidate name
email	string	true	candidate email
phoneNo	string	true	candidate phone number
scheduleTime	string[]	true	array of starting time and ending time of the interview with the timings in ISO string format Allowed format: `["2022-12-24T05:43:18.294Z", "2022-12-24T06:43:18.294Z"]` Timings should be between `10:00 AM` and `8:00 PM`
resume	object	false	resume object

Resume object

Parameter	Type	Required	Description
fileName	string	true	resume file name
url	string	true	public resume url

Get rounds and rubrics

curl --location --request GET 'https://api.intervue.io/mock-interviews/getRole/{hiringRoleId}' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/mock-interviews/getRole/{hiringRoleId}"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "post",
  url: "https://api.intervue.io/mock-interviews/getRole/{hiringRoleId}",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
  data: data,
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/mock-interviews/getRole/{hiringRoleId}")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "roundDetails": {
    "roundName": "Data Structure & Algorithms",
    "roundDescription": ""
  },
  "rubrics": [
    {
      "name": "Functionally correct solution",
      "description": "End to end working solution"
    },
    {
      "name": "Performant",
      "description": "Complexity analysis & optimizations, opportunity of parallelism"
    },
    {
      "name": "Pseudo code",
      "description": "Rough code without any language specific semantics"
    },
    {
      "name": "Corner Cases",
      "description": "Gauge edge case handling in the solution"
    },
    {
      "name": "Data Structure",
      "description": "Right use of data structures"
    },
    {
      "name": "Core knowledge",
      "description": "Types, channels, Go-routines, mutex, struct, concurrency, parallelism etc."
    },
    {
      "name": "Micro-services in Go, caching & databases",
      "description": "Data caching, relational DBMS vs NoSQL"
    }
  ]
}

Get rounds and rubrics supported for mock interviews for a given hiring role ID.

HTTP Request

POST https://api.intervue.io/mock-interviews/getRole/{hiringRoleId}

Path Parameters

Parameter	Type	Required	Description
hiringRoleId	integer	true	hiring role id

Get supported profiles

curl --location --request GET 'https://api.intervue.io/mock-interviews/getProfilesSupported' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/mock-interviews/getProfilesSupported"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/mock-interviews/getProfilesSupported",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/mock-interviews/getProfilesSupported")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "profileList": [
    {
      "key": "FRONTEND",
      "profile": "Frontend",
      "description": "Eg. React, HTML, Angular, Vue, CSS, Javascript",
      "seniorityList": [
        {
          "key": "Entry-level",
          "seniority": "Entry Level",
          "description": "For person with experience of 0-1 yrs",
          "skillList": [
            {
              "skill": "Frontend Fundamentals",
              "hiringRoleId": 724
            },
            {
              "skill": "React JS",
              "hiringRoleId": 9
            },
            {
              "skill": "Angular JS",
              "hiringRoleId": 8
            },
            {
              "skill": "Vue JS",
              "hiringRoleId": 764
            }
          ],
          "skillsAvailable": true
        }
      ]
    },
    {
      "key": "BACKEND",
      "profile": "Backend",
      "description": "Eg. Java, NodeJS, Python, Go, system design",
      "seniorityList": [
        {
          "key": "Entry-level",
          "seniority": "Entry Level",
          "description": "For person with experience of 0-1 yrs",
          "hiringRoleId": 10,
          "skillsAvailable": false
        }
      ]
    }
  ]
}

Get all the profiles supported for mock interviews on Intervue

HTTP Request

GET https://api.intervue.io/mock-interviews/getProfilesSupported

Response

If skillsAvailable is true then, skillList will be present in the response,
else if skillsAvailable is false, hiringRoleId will be present

Get interview information

curl --location --request GET 'https://api.intervue.io/mock-interviews/getInterviewInfo/interviewId' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/mock-interviews/getInterviewInfo/interviewId"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/mock-interviews/getInterviewInfo/interviewId",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/mock-interviews/getInterviewInfo/interviewId")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "data": {
    "interviewId": "12395361-5034-4c90-86fe-b59dd8ffe520",
    "hiringRoleId": 9,
    "candidateProfile": "FRONTEND",
    "seniority": "Entry-level",
    "round": "Libraries & Frameworks",
    "resume": {
      "url": null,
      "fileName": null
    },
    "status": "UN_SCHEDULED",
    "candidate": {
      "name": "abc",
      "email": "xyz@gmail.com",
      "phoneNo": "1234567890"
    }
  }
}

Get a particular mock interview information

HTTP Request

GET https://api.intervue.io/mock-interviews/getInterviewInfo/{interviewId}

Path Parameters

Parameter	Type	Required	Description
interviewId	uuid(string)	true	the interview ID to get response of

Get candidate information

curl --location --request GET 'https://api.intervue.io/mock-interviews/getCandidateInfo?email=email' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/mock-interviews/getCandidateInfo?email=email"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/mock-interviews/getCandidateInfo?email=email",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/mock-interviews/getCandidateInfo?email=email")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "data": {
    "name": "abc",
    "email": "xyz@gmail.com",
    "phoneNo": "1234567890"
  }
}

Get the information of a given candidate by email

HTTP Request

GET https://api.intervue.io/mock-interviews/getCandidateInfo

Query Parameters

Parameter	Type	Required	Description
email	string	true	the email of the candidate for whom to get the information of

Home Assignments

Get assignments

curl --location --request GET 'https://api.intervue.io/assignments/list' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/assignments/list"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/assignments/list",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/assignments/list")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "data": [
    {
      "name": "test name",
      "mainTestUrlHash": "test url hash",
      "disabled": false,
      "publishStatus": "LIVE",
      "createdAt": "2021-12-12T21:16:47.754Z",
      "updatedAt": "2022-12-27T09:06:49.691Z",
      "duration": 30,
      "description": "test description",
      "fromLibrary": true,
      "totalInvitations": 1,
      "publicUrl": "public url",
      "invitations": [
        {
          "activeTestId": 1242,
          "inviteSentOn": "2022-12-14T15:10:38.459Z",
          "invitationsCount": 1
        }
      ],
      "candidatesInvited": [
        {
          "invitedOn": "2022-12-14T15:10:38.473Z",
          "candidateName": "candidate name",
          "candidateEmail": "candidate email",
          "activeTestId": 1242,
          "invitationUrlHash": "invitation url hash"
        }
      ]
    }
  ],
  "totalResults": 1,
  "next": true
}

Get all the assignments avaialble

HTTP Request

GET https://api.intervue.io/assignments/list

Query Parameters

Parameter	Type	Required	Description
pageNumber	integer	false	the page number to get result of `>=1` Default: `1`
pageSize	integer	false	the number of rows to return at a time `>=1` Default: `10`
publishStatus	string	false	the published status of the assingment Allowed values: `LIVE`, `DRAFT`
hideDisabled	boolean	false	whether to hide disabled assingments or not
sortByDirection	string	false	the direction in which to sort the results Default: `DESC` Allowed values: `ASC`, `DESC`

Disable assignment

curl --location --request PATCH 'https://api.intervue.io/assignments/disable/testUrlHash' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/assignments/disable/testUrlHash"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("PATCH", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "patch",
  url: "https://api.intervue.io/assignments/disable/testUrlHash",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/assignments/disable/testUrlHash")
  .method("PATCH")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "message": "Test disabled"
}

Disable a test

HTTP Request

PATCH https://api.intervue.io/assignments/disable/{testUrlHash}

Path Parameters

Parameter	Type	Required	Description
testUrlHash	string	true	the url hash of the test to disable

Archive assignment

curl --location --request PATCH 'https://api.intervue.io/assignments/archive/testUrlHash' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/assignments/archive/testUrlHash"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("PATCH", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "patch",
  url: "https://api.intervue.io/assignments/archive/testUrlHash",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/assignments/archive/testUrlHash")
  .method("PATCH")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "message": "Test archived"
}

Archive a test

HTTP Request

PATCH https://api.intervue.io/assignments/archive/{testUrlHash}

Path Parameters

Parameter	Type	Required	Description
testUrlHash	string	true	the url hash of the test to archive

Delete assingment

curl --location --request DELETE 'https://api.intervue.io/assignments/testUrlHash' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/assignments/testUrlHash"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("DELETE", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "delete",
  url: "https://api.intervue.io/assignments/testUrlHash",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue-dev.io/assignments/testUrlHash")
  .method("DELETE")
  .addHeader("Authorization", "Basic amFqYWphamE6YmFiYWJhYmE=")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "message": "test removed successfully!"
}

Delete an assignment using its test URL hash, to delete an intervue you need to archieve it first.

HTTP Request

DELETE https://api.intervue.io/assignments/{testUrlHash}

Path Parameters

Parameter	Type	Required	Description
testUrlHash	string	true	the url hash of the test to delete

Get skills available

curl --location --request GET 'https://api.intervue.io/assignments/getSkills' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/assignments/getSkills"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/assignments/getSkills",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/assignments/getSkills")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "skillList": [
    {
      "skillName": "Skill 1",
      "skillId": 9
    },
    {
      "skillName": "Skill 2",
      "skillId": 10
    }
  ]
}

Get the skills available on Intervue

HTTP Request

GET https://api.intervue.io/assignments/getSkills

Get test configuration

curl --location --request GET 'https://api.intervue.io/assignments/getTestConfiguration?seniority=10&skills[]=1&skills[]=2' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/assignments/getTestConfiguration?seniority=10&skills[]=1&skills[]=2"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/assignments/getTestConfiguration?seniority=10&skills[]=1&skills[]=2",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/assignments/getTestConfiguration?seniority=10&skills[]=1&skills[]=2")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "configuration": [
    {
      "skill": {
        "name": "skill-1",
        "id": 1
      },
      "config": [
        {
          "questionType": "PROGRAMMING",
          "difficultyLevel": "EASY",
          "questionsCount": 1,
          "maxQuestionsCount": 1
        }
      ]
    },
    {
      "skill": {
        "name": "skill-2",
        "id": 2
      },
      "config": [
        {
          "questionType": "MCQ",
          "difficultyLevel": "EASY",
          "questionsCount": 2,
          "maxQuestionsCount": 6
        },
        {
          "questionType": "SUBJECTIVE",
          "difficultyLevel": "HARD",
          "questionsCount": 1,
          "maxQuestionsCount": 1
        }
      ]
    }
  ],
  "duration": 50
}

Get test configuration for the given skills and seniority

HTTP Request

GET https://api.intervue.io/assignments/getTestConfiguration

Query Parameters

Parameter	Type	Required	Description
skills	array of ids	true	the id of skills for which to get configuration
seniority	integer	true	the seniority for which to get configuration (number of years)

Create test

curl --location --request POST 'https://api.intervue.io/assignments/createTest/' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \
--data-raw '{
    "randomForEachCandidate": true,
    "testName": "test 4",
    "testConfig": [
        {
            "skill": {
                "name": "skill-1",
                "id": 1
            },
            "config": [
                {
                    "difficultyLevel": "EASY",
                    "questionsCount": 1,
                    "variantType": "MCQ"
                }
            ]
        },
        {
            "skill": {
                "name": "skill-2",
                "id": 2
            },
            "config": [
                {
                    "difficultyLevel": "EASY",
                    "questionsCount": 2,
                    "variantType": "MCQ"
                }
            ]
        }
    ]
}
'

import requests
import json

url = "https://api.intervue.io/assignments/createTest/"

payload = json.dumps({
    "randomForEachCandidate": true,
    "testName": "test 4",
    "testConfig": [
        {
            "skill": {
                "name": "skill-1",
                "id": 1
            },
            "config": [
                {
                    "difficultyLevel": "EASY",
                    "questionsCount": 1,
                    "variantType": "PROGRAMMING"
                }
            ]
        },
        {
            "skill": {
                "name": "skill-2",
                "id": 2
            },
            "config": [
                {
                    "difficultyLevel": "EASY",
                    "questionsCount": 2,
                    "variantType": "MCQ"
                }
            ]
        }
    ]
}
)
headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

const axios = require("axios");
const data = JSON.stringify({
  randomForEachCandidate: true,
  testName: "test 4",
  seniority: "Internship",
  testConfig: [
    {
      skill: {
        name: "skill-1",
        id: 1,
      },
      config: [
        {
          difficultyLevel: "EASY",
          questionsCount: 1,
          variantType: "MCQ",
        },
      ],
    },
    {
      skill: {
        name: "skill-2",
        id: 2,
      },
      config: [
        {
          difficultyLevel: "EASY",
          questionsCount: 2,
          variantType: "MCQ",
        },
      ],
    },
  ],
});

const config = {
  method: "post",
  url: "https://api.intervue.io/assignments/createTest/",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
  data: data,
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, '{"randomForEachCandidate":true,"testName":"test 4","seniority":"Internship","testConfig":[{"skill":{"name":"skill-1","id":1},"config":[{"difficultyLevel":"EASY","questionsCount":1,"variantType":"MCQ"}]},{"skill":{"name":"skill-2","id":2},"config":[{"difficultyLevel":"EASY","questionsCount":2,"variantType":"MCQ"}]}]}');
Request request = new Request.Builder()
  .url("https://api.intervue.io/assignments/createTest/")
  .method("POST", body)
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "message": "Test published successfully!",
  "data": {
    "testName": "test name",
    "mainTestUrlHash": "main test url hash",
    "duration": 50
  }
}

Create a test

HTTP Request

POST https://api.intervue.io/assignments/createTest/

Body Parameters

Parameter	Type	Required	Description
testName	string	true	name of the test
description	string	false	descripton of the test
cutOffMarksPercentage	integer	false	cutoff for the test
randomForEachCandidate	boolean	true	randomise questions for every candidate
testConfig	array of testConfig object	true	testConfig for the test
takeSnapshot	boolean	false	ask for snapshot from candidate on entring the test
mandatoryTakeSnapshot	boolean	false	making snapshot from candidate on entring the test mandatory
duration	integer	false	duration of the test

`testConfig` object

Parameter	Type	Required	Description
skillName	string	true	name of the skill
config	array of config object	true	config of the questions

`config` object

Parameter	Type	Required	Description
difficultyLevel	string	true	difficulty level of the question. Allowed values: `EASY`,`MEDIUM`,`HARD`
questionsCount	integer	true	the number of questions required
variantType	type of question	true	type of question. Allowed values: `PROGRAMMING`,`MCQ`,`SUBJECTIVE`

Send invitations

curl --location --request POST 'https://api.intervue.io/assignments/send-invitations' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \
--data-raw '{
  "mainTestUrlHash": "main test url hash",
  "candidates": [
    {
      "email": "Candidate email",
      "name": "Candidate name"
    }
  ],
  "expiryDate": "2023-01-29T18:32:26.411Z",
  "emailReplyTo": "Reply email",
  "emailSubject": "Subject"
}'

import requests
import json

url = "https://api.intervue.io/assignments/send-invitations"

payload = json.dumps({
  "mainTestUrlHash": "main test url hash",
  "candidates": [
    {
      "email": "Candidate email",
      "name": "Candidate name"
    }
  ],
  "expiryDate": "2023-01-29T18:32:26.411Z",
  "emailReplyTo": "Reply email",
  "emailSubject": "Subject"
})
headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

const axios = require("axios");
const data = JSON.stringify({
  mainTestUrlHash: "main test url hash",
  candidates: [
    {
      email: "Candidate email",
      name: "Candidate name",
    },
  ],
  expiryDate: "2023-01-29T18:32:26.411Z",
  emailReplyTo: "Reply email",
  emailSubject: "Subject",
});

const config = {
  method: "post",
  url: "https://api.intervue.io/assignments/send-invitations",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
  data: data,
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\"mainTestUrlHash\":\"main test url hash\",\"candidates\":[{\"email\":\"Candidate email\",\"name\":\"Candidate name\"}],\"expiryDate\":\"2023-01-29T18:32:26.411Z",\"emailReplyTo\":\"Reply email\",\"emailSubject\":\"Subject\"}");
Request request = new Request.Builder()
  .url("https://api.intervue.io/assignments/send-invitations")
  .method("POST", body)
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "activeTestId": 123,
  "candidates": [
    {
      "name": "Candidate name",
      "email": "Candidate email",
      "invitationUrlHash": "invitation url hash"
    }
  ]
}

Send invitations for given assignment

HTTP Request

POST https://api.intervue.io/assignments/send-invitations

Body Parameters

Parameter	Type	Required	Description
mainTestUrlHash	string	true	main test url hash of the assignment
candidates	Array of candidate object	true	array of candidates
expiryDate	date string	true	expiration date of the test in date string in ISO format
emailReplyTo	string	false	email at which you want replies to
emailSubject	string	false	subject of the invitation email
startDate	date string	false	starting date of the test in date string in ISO format
finalEntryDate	date string	false	final entry date of the test in date string in ISO format
disableCommunications	boolean	false	whether to disable sending communications to candidates from Intervue

Candidate object for invitation

Parameter	Type	Required	Description
email	string	true	email of the candidate
name	string	true	name of the candidate

Create public link

curl --location --request POST 'https://api.intervue.io/assignments/createPublicLink/' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \
--data-raw '{
  "mainTestUrlHash": "main test url hash",
  "testStartTime": "2023-01-29T18:32:26.411Z",
  "expiresOn": "2023-01-29T18:32:26.411Z"
}'

import requests
import json

url = "https://api.intervue.io/assignments/createPublicLink/"

payload = json.dumps({
  "mainTestUrlHash": "main test url hash",
  "testStartTime": "2023-01-29T18:32:26.411Z",
  "expiresOn": "2023-01-29T18:32:26.411Z"
})
headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

const axios = require("axios");
const data = JSON.stringify({
  mainTestUrlHash: "main test url hash",
  testStartTime: "2023-01-29T18:32:26.411Z",
  expiresOn: "2023-01-29T18:32:26.411Z",
});

const config = {
  method: "post",
  url: "https://api.intervue.io/assignments/createPublicLink/",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
  data: data,
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, '{"mainTestUrlHash":"main test url hash","testStartTime":"2023-01-29T18:32:26.411Z","expiresOn":"2023-01-29T18:32:26.411Z"}');
Request request = new Request.Builder()
  .url("https://api.intervue.io/assignments/createPublicLink/")
  .method("POST", body)
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "uniqueId": "38d9bbda-47a1-4421-a39e-acef8c99d87e",
  "mainTestUrlHash": "main test url hash",
  "testStartTime": "2023-01-29T18:32:26.411Z",
  "expiresOn": "2023-01-29T18:32:26.411Z"
}

Create public link for given assignment

HTTP Request

POST https://api.intervue.io/assignments/createPublicLink/

Body Parameters

Parameter	Type	Required	Description
mainTestUrlHash	string	true	main test url hash of the assignment
testStartTime	date string	false	start date of the test in date string in ISO format
expiresOn	date string	false	expiration date of the test in date string in ISO format

Get assignment results

curl --location --request GET 'https://api.intervue.io/assignments/results' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/assignments/results"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/assignments/results",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/assignments/results")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "data": [
    {
      "invitationUrlHash": "invitation url hash",
      "testName": "test name",
      "testExpiryDate": "2022-12-20T15:10:33.000Z",
      "testStartDate": null,
      "duration": 30,
      "candidateEmail": "candidate email",
      "candidateName": "candidate name",
      "disabled": false,
      "shortListed": null,
      "testCasesCheckStatus": null,
      "reportUuid": "report uuid",
      "activeTestId": 1242,
      "tabSwitches": null,
      "fullScreenExits": null,
      "percentageScored": null,
      "scoringEvaluationStatus": "UN_EVALUATED",
      "passedScoring": null,
      "isLocked": false,
      "invitationSendSuccess": true,
      "autoDisqualified": false,
      "totalAttempted": null,
      "totalQuestions": 1,
      "testFinalEntryDate": null,
      "test": {
        "testUrlHash": "test url hash",
        "name": "test name"
      }
    }
  ],
  "totalResults": 1,
  "next": false
}

Get all the information regarding an assignment

HTTP Request

GET https://api.intervue.io/assignments/results

Query Parameters

Parameter	Type	Required	Description
pageNumber	integer	false	the page number to get result of `>=1` Default: `1`
pageSize	integer	false	the number of rows to return at a time `>=1` Default: `10`
sortBy	string	false	the field with which to sort by Allowed values: `createdAt` `candidateName` `interviewExpiryDate` `candidateEmail` `percentageScored` `interviewTimeTaken`
sortByDirection	string	false	the direction in which to sort the results Default: `DESC` Allowed values: `ASC`, `DESC`
shortListed	boolean	false	whether the candidate is shortlisted
activeTestId	integer	false	the active test ID of an assignment
testUrlHash	string	false	the test url hash or the main test url hash of an assignment
assignmentStatus	string	false	the status of the assignment to filter by Allowed values: `INVITE_FAILED` `EVALUATION_PENDING` `CANDIDATE_SHORTLISTED` `INTERVIEW_ENDED` `INTERVIEW_EXPIRED` `INVITATION_SENT` `INTERVIEW_STARTED`

Get test report

curl --location --request GET 'https://api.intervue.io/assignments/report/invitationUrlHash' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/assignments/report/invitationUrlHash"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/assignments/report/invitationUrlHash",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/assignments/report/invitationUrlHash")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "data": {
    "interviewDuration": 30,
    "testCasesCheckStatus": null,
    "interviewToBeEndedAt": null,
    "interviewName": null,
    "interviewEndedAt": null,
    "interviewStartedAt": null,
    "invitationUrlHash": "invitation url hash",
    "shortListed": null,
    "percentageScored": null,
    "passedScoring": null,
    "autoDisqualified": false,
    "sectionWiseScores": [],
    "testUrlHash": "test url hash",
    "test": {
      "urlHash": "test url hash",
      "name": "test name",
      "expiryDate": null,
      "duration": 30,
      "disabled": false,
      "publishStatus": "LIVE",
      "description": "test description",
      "cutOffMarksPercentage": 60,
      "result": [
        {
          "question": "Nth Natural Number",
          "questionType": "Programming",
          "sectionName": "section name",
          "isCorrect": false,
          "evaluationResult": "Unevaluated",
          "maxPoints": 20,
          "pointsEarned": null,
          "attempted": "No"
        }
      ]
    },
    "plagiarism": "NA",
    "candidateInfo": null,
    "editEventsCount": 0,
    "candidateName": "candidate name",
    "candidateEmail": "candidate email",
    "codeLink": "code link",
    "playBackLink": "playback link"
  }
}

Get test report of a completed assignment for the given invitation url hash

HTTP Request

GET https://api.intervue.io/assignments/report/{invitationUrlHash}

Path Parameters

Parameter	Type	Required	Description
invitationUrlHash	string	true	the invitation url hash of an assignment

Get detailed test report

curl --location --request GET 'https://api.intervue.io/assignments/detailed-report/testUrlHash' \
--header 'Authorization: Basic <ENCODED_KEY>' \
--header 'Content-Type: application/json' \

import requests
import json

url = "https://api.intervue.io/assignments/detailed-report/testUrlHash"

headers = {
  'Authorization': 'Basic <ENCODED_KEY>',
  'Content-Type': 'application/json'
}

response = requests.request("GET", url, headers=headers)

print(response.text)

const axios = require("axios");

const config = {
  method: "get",
  url: "https://api.intervue.io/assignments/detailed-report/testUrlHash",
  headers: {
    Authorization: "Basic <ENCODED_KEY>",
    "Content-Type": "application/json",
  },
};

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

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://api.intervue.io/assignments/detailed-report/testUrlHash")
  .method("GET")
  .addHeader("Authorization", "Basic <ENCODED_KEY>")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();

{
  "status": 200,
  "data": [
    {
      "testUrlHash": "test url hash",
      "candidateName": "candidate name",
      "candidateEmail": "candidate email",
      "shortListed": "NA",
      "interviewStartedAt": "NA",
      "interviewEndedAt": "NA",
      "scoringEvaluationStatus": "assignment evaluation status",
      "status": "not submitted",
      "timeTaken": "NA",
      "plagiarism": "NA",
      "reportLink": "report link",
      "others_attempted": 0,
      "candidateInfo": {
        "college": "NA",
        "major": "NA",
        "city": "NA",
        "rollNumber": "NA",
        "phoneNumber": "NA",
        "degree": "NA",
        "cgpa": "NA",
        "stream": "NA",
        "resume": null
      },
      "result": [
        {
          "question": "Nth Natural Number",
          "questionType": "Programming",
          "evaluationResult": "Unevaluated",
          "maxPoints": 20,
          "pointsEarned": null,
          "attempted": "No"
        }
      ]
    }
  ],
  "totalResults": 1,
  "next": false
}

Get detailed test report for the given invitation url hash

HTTP Request

GET https://api.intervue.io/assignments/detailed-report/{testUrlHash}

Path Parameters

Parameter	Type	Required	Description
testUrlHash	string	true	the test url hash of an assignment

Note: testUrlHash can be the test url hash or the main test url hash of an assignment

Query Parameters

Parameter	Type	Required	Description
pageNumber	integer	false	the page number to get result of `>=1` Default: `1`
pageSize	integer	false	the number of rows to return at a time `>=1` Default: `10`
activeTestId	integer	false	the active test ID to get results of
email	string	false	returns the results of the given candidate email

Webhooks

Use webhooks to get notified about events related to the intervue.io interview flows.

Webhook Vs API

APIs send you the data when you request it. For Webhooks, you do not need to make a request. You receive the data when it is available.

key                = webhook_secret
message            = webhook_body // raw webhook request body
received_signature = webhook_signature

expected_signature = hmac('sha256', message, key)

if expected_signature != received_signature
    throw SecurityError
end

//  use Caesar (version 0.6.0 or later):


// key                = webhook_secret
// message            = webhook_body // raw webhook request body
// received_signature = webhook_signature
int blockSize = 128;
String secretKey = "";
String message = "";

String expected_signature = new Hmac(
      new ImmutableMessageDigest(
          MessageDigest.getInstance("SHA-256")
      ),
      blockSize,
      new PlainText(secretKey),
      new PlainText(message)
  ).asHexString()

if (expected_signature != received_signature) {
  throw Error("invalid signature")
}

# key                = webhook_secret
# message            = webhook_body // raw webhook request body
# received_signature = webhook_signature
import hmac
import hashlib
import base64

signing_input = b""
key = b""

# Decode the key.  Pad it with '=' characters to a length divisible by 4
# as expected by urlsafe_b64decode
if len(key) % 4 == 2:
    key += b'=='
elif len(key) % 4 == 3:
    key += b'='

key = base64.urlsafe_b64decode(key)

signature = hmac.digest(key, signing_input, digest=hashlib.sha256)
signature = base64.urlsafe_b64encode(signature)

# Strip off any '=' characters urlsafe_b64encode added to pad the key to
# a length divisible by 4
expected_signature = signature.rstrip(b'=')

if expected_signature !== received_signature:
  raise Exception("invalid signature")

// key                = webhook_secret
// message            = webhook_body // raw webhook request body
// received_signature = webhook_signature
let hash = CryptoJS.HmacSHA256("message", "key");
const expected_signature = CryptoJS.enc.Base64.stringify(hash);
if (expected_signature !== received_signature) {
  throw Error("invalid signature");
}

Register webhook

Log into you intervue.io account
Go to settings page
Click "Developer settings" tab
Paste your webhook url - POST endpoint
Click save to save your endpoint
On clicking save you'll recieve an webhook secret, save it

Validate webhook

When your webhook secret is set, intervue.io uses it to create a hash signature with each payload. This hash signature is passed with each request under the X-Intervue-Signature header that you need to validate at your end.

Header	Description
X-intervue-signature	The hash signature is calculated using HMAC with SHA256 algorithm; with your webhook secret set as the key and the webhook request body as the message.

External interviews webhooks

Events

Event	Description
requested	Event is generated whenever a new On-demand interview request is raised
canceled	Event is generated whenever an On-demand interview is canceled by (intervue/candidate/organisation)
scheduled	Event is generated whenever an On-demand interview is scheduled
completed	Event is generated whenever an On-demand interview is completed and report is generated (does not include video playback)
videoGenerationCompleted	Event is generated whenever an On-demand interview is completed and video playback is generated

Requested event

{
  "status": "requested",
  "interviewId": "interview uuid",
  "requestedData": {
    "requestedAt": "2022-12-21T09:47:08.882Z",
    "requestedBy": { "name": "team member name", "email": "team member email" },
    "candidate": {
      "email": "candidate email",
      "name": "candidate name",
      "phone": "candidate phone number"
    }
  }
}

This event is triggered when interview is requested by the organisation

Parameter	Type	Required	Description
status	string	true	`requested` key
interviewId	string(uuid)	true	unique id of interview in UUIDv4 format
requestedData	requestedData object	true	object with data for requested interview

`requestedData` object

Parameter	Type	Required	Description
requestedAt	string	true	Date String in ISO format when the interview was requested
requestedBy	requestedBy object	true	Object containing the user who initiated the request
candidate	candidate object	true	Object containing info regarding

`requestedBy` object

Parameter	Type	Required	Description
name	string	true	name of the team member
email	string	true	email of the team member

Canceled event

{
  "status": "canceled",
  "interviewId": "interview uuid",
  "requestedData": {
    "canceledBy": "intervue/candidate/organisation",
    "canceledDateTime": "2022-12-21T09:47:08.882Z",
    "scheduleDateTime": "2022-12-21T09:47:08.882Z", // only if interview was scheduled
    "candidate": {
      "email": "candidate email",
      "name": "candidate name",
      "phone": "candidate phone number"
    }
  }
}

This event is triggered when interview is canceled by organisation, candidate or intervue team

Parameter	Type	Required	Description
status	string	true	`canceled` key
interviewId	string(uuid)	true	unique id of interview in UUIDv4 format
cancelData	cancelData object	true	object with data for canceled interview

`cancelData` object

Parameter	Type	Required	Description
canceledBy	string	true	can be one of 'candidate', 'organisation' or 'intervue'
canceledDateTime	string	true	Date String in ISO format when the interview was canceled
scheduleDateTime	string	false	Date String in ISO format of schedule time if the interview was scheduled
candidate	candidate object	true	Object containing info regarding

Scheduled event

{
  "status": "scheduled",
  "interviewId": "interview uuid",
  "requestedData": {
    "scheduleDateTime": "2022-12-21T09:47:08.882Z",
    "candidate": {
      "email": "candidate email",
      "name": "candidate name",
      "phone": "candidate phone number"
    }
  }
}

This event is triggered when requested interview is scheduled by intervue team

Parameter	Type	Required	Description
status	string	true	`scheduled` key
interviewId	string(uuid)	true	unique id of interview in UUIDv4 format
scheduleData	scheduleData object	true	object with data for scheduled interview

`scheduleData` object

Parameter	Type	Required	Description
scheduleDateTime	string	true	Date String in ISO format of schedule time if the interview was scheduled
candidate	candidate object	true	Object containing info regarding

Completed event

{
  "status": "completed",
  "interviewId": "interview uuid",
  "requestedData": {
    "candidate": {
      "email": "candidate email",
      "name": "candidate name",
      "phone": "candidate phone number"
    },
    "interviewerCredentials": "interviewer credential string",
    "scheduleDateTime": "2022-12-21T09:47:08.882Z",
    "interviewDuration": "1 hour 2 minutes",
    "verdict": {
      "index": "0/1/2/3",
      "text": "Strong no/No/Yes/Strong yes"
    },
    "feedbacks": [
      {
        "title": "Feedback title",
        "criteriaDecision": "Decision text",
        "rating": "0/1-10",
        "reviewHtml": "Review text in HTML"
      }
    ],
    "urls": {
      "playback": "playback url",
      "report": "report url"
    }
  }
}

This event is triggered when scheduled interview is completed and report is generated

Parameter	Type	Required	Description
status	string	true	`completed` key
interviewId	string(uuid)	true	unique id of interview in UUIDv4 format
reportData	reportData object	true	object with data for completed interview

`reportData` object

Parameter	Type	Required	Description
scheduleDateTime	string	true	Date String in ISO format of schedule time if the interview was scheduled
interviewerCredentials	string	true	interviewer credntials
interviewDuration	string	true	interview duration in following format `1 hour 2 minutes`
verdict	verdict object	true	Object containing info regarding verdict of interview
feedback	feedback object Array	true	Array containing objects containing interviewer feedback
candidate	candidate object	true	Object containing info regarding candidate
urls	urls object	true	Object containing info regarding report urls

`verdict` object

Parameter	Type	Required	Description
index	number	true	0/1/2/3
text	string	true	'Strong no'/'No'/'Yes'/'String yes'

`urls` object

Parameter	Type	Required	Description
playback	string	true	interview playback url
report	string	true	downloadable report pdf url

`feedback` object

Parameter	Type	Required	Description
title	string	true	title of the feedback
criteriaDecision	string	true	criteria decision text
reviewHtml	string	true	review of the interviewer in html format
rating	number	true	rating index 0 or 1-10

Video Generation Completed event

{
  "status": "videoGenerationCompleted",
  "interviewId": "interview uuid",
  "requestedData": {
    "url": "playback url"
  }
}

This event is triggered when video processing is finally done and playback url is generated with the requested interview

Parameter	Type	Required	Description
status	string	true	`videoGenerationCompleted` key
interviewId	string(uuid)	true	unique id of interview in UUIDv4 format
videoPlaybackData	videoPlaybackData object	true	object with url for video playback

`videoPlaybackData` object

Parameter	Type	Required	Description
url	string	true	url of the interview playback with video

Candidate object

{
  "candidate": {
    "email": "candidate email",
    "name": "candidate name",
    "phone": "candidate phone number"
  }
}

Parameter	Type	Required	Description
name	string	true	name of the candidate
email	string	true	email of the candidate
phoneNo	string	true	phone number of the candidate

Home Assignments webhooks

Home assignment events

Event	Description
test_started	Event is generated whenever a test is started by a candidate
test_ended	Event is generated whenever a test ends
quota_finished	Event is generated whenever quota finishes
test_report_generated	Event is generated whenever the report of a test is generated
reminder	Event is generated when opted out for communications and sends reminder to before 1 hour
invitation_sent	Event is generated whenever invitation job is finished

Test started event

{
  "status": "test_started",
  "invitationUrlHash": "invitation url hash",
  "testData": {
    "startedAt": "2022-12-21T09:47:08.882Z",
    "questions": [
      {
        "question": "question heading",
        "questionType": "Programming",
        "maxPoints": 100
      }
    ],
    "candidate": {
      "email": "candidate email",
      "name": "candidate name",
      "phone": "candidate phone number"
    }
  }
}

This event is triggered when a test is started by a candidate

Parameter	Type	Required	Description
status	string	true	`test_started` key
invitationUrlHash	string	true	unique id of interview in UUIDv4 format
testData	testData object	true	object with data for started test

`testData` object

Parameter	Type	Required	Description
startedAt	string	true	Date String in ISO format when the test was started
questions	array of questions object	true	array with information about the questions
candidate	candidate object	true	object with data for the candidate

`questions` object

Parameter	Type	Required	Description
question	string	true	the heading of the question
questionType	string	true	type of the question
maxPoints	integer	true	maximum points earned from the question

`candidate` object

Parameter	Type	Required	Description
name	string	true	name of the candidate
email	string	true	email of the candidate
phoneNo	string	true	phone no of the candidate

Test ended event

{
  "status": "test_ended",
  "invitationUrlHash": "invitation url hash",
  "testData": {
    "endedAt": "2022-12-21T09:47:08.882Z",
    "questions": [
      {
        "question": "question heading",
        "questionType": "Programming",
        "maxPoints": 100
      }
    ],
    "candidate": {
      "email": "candidate email",
      "name": "candidate name",
      "phone": "candidate phone number"
    }
  }
}

This event is triggered when a test ends

Parameter	Type	Required	Description
status	string	true	`test_ended` key
invitationUrlHash	string	true	unique id of interview in UUIDv4 format
testData	testData object	true	object with data for the test ended

`testData` object

Parameter	Type	Required	Description
endedAt	string	true	Date String in ISO format when the test was ended
questions	array of questions object	true	array with information about the questions
candidate	candidate object	true	object with data for the candidate

`questions` object

Parameter	Type	Required	Description
question	string	true	the heading of the question
questionType	string	true	type of the question
maxPoints	integer	true	maximum points earned from the question
pointsEarned	integer	true	points earned from the question
isCorrect	boolean	true	is the answer is correct
attempted	boolean	true	is the question attempted
evaluationStatus	string	true	evaluation status of the question

`candidate` object

Parameter	Type	Required	Description
name	string	true	name of the candidate
email	string	true	email of the candidate
phoneNo	string	true	phone no of the candidate

Plan quota finished

{
  "status": "quota_finished",
  "assignmentPublicLink": "public link of the assignment",
  "planData": {
    "planStartDate": "2022-10-21T09:47:08.882Z",
    "planEndDate": "2022-12-21T09:47:08.882Z",
    "message": "reason for quota finished",
    "planName": "name of the plan",
    "isTrialPlan": false
  }
}

This event is triggered when the plan usage quota has finished

Parameter	Type	Required	Description
status	string	true	`quota_finished` key
assignmentPublicLink	string	true	public link of the assignment
planData	planData object	true	object with data for the plan

`planData` object

Parameter	Type	Required	Description
message	string	true	the reason for the quota to finish
planStartDate	string	true	Date String in ISO format of current plan start date
planEndDate	string	true	Date String in ISO format of current plan end date
planName	string	true	the name of the current plan
isTrialPlan	boolean	true	whether the current plan is free

Test report generated

{
  "status": "test_report_generated",
  "reportData": {
    "testUrlHash": "url hash for the assignment",
    "percentageScored": 23,
    "sectionWiseScores": [
      {
        "maxPoints": 100,
        "pointsEarned": 12,
        "sectionName": "section name"
      }
    ],
    "candidate": {
      "email": "candidate email",
      "name": "candidate name",
      "phoneNo": "9991919199"
    }
  }
}

This event is triggered when the plan usage quota has finished

Parameter	Type	Required	Description
status	string	true	`test_report_generated` key
reportData	reportData object	true	object with data for the report

`reportData` object

Parameter	Type	Required	Description
testUrlHash	string	true	the reason for the quota to finish
percentageScored	number	true	percentage scored
sectionWiseScores	array of section score objects	true	score details associated with each section
candidate	candidate object	true	candidate object

Reminder

{
  "status": "reminder",
  "reminderData": {
    "assignmentList": [
      {
        "invitationUrlHash": "invitation url hash for the assignment",
        "testUrlHash": "url hash for the assignment",
        "startDate": "2022-10-21T09:47:08.882Z",
        "candidate": {
          "email": "candidate email",
          "name": "candidate name"
        }
      }
    ]
  }
}

This event is triggered when the plan usage quota has finished

Parameter	Type	Required	Description
status	string	true	`reminder` key
reminderData	reminderData object	true	object with data for the reminder

`reminderData` object

Parameter	Type	Required	Description
assignmentList	array of assignment objects	true	assignment details for the reminder

`assignmentList` object

Parameter	Type	Required	Description
invitationUrlHash	string	true	invitation url hash for the assignment
testUrlHash	string	true	url hash for the assignment
startDate	string	true	Date String in ISO format of assignment start date
candidate	candidate object	true	candidate details for the assignment

`candidate` object

Parameter	Type	Required	Description
name	string	true	name of the candidate
email	string	true	email of the candidate

Invitation sent

{
  "status": "invitation_sent",
  "invitationData": {
    "magicLink": "magic link of the assignment",
    "invitationUrlHash": "invitation url hash for the assignment",
    "candidate": {
      "email": "candidate email",
      "name": "candidate name",
      "phoneNo": "9991919199"
    }
  }
}

This event is triggered when the plan usage quota has finished

Parameter	Type	Required	Description
status	string	true	`invitation_sent` key
invitationData	invitationData object	true	object with data for the reminder

`invitationData` object

Parameter	Type	Required	Description
magicLink	string	true	magic link of the assignment
invitationUrlHash	string	true	invitation url hash for the assignment
candidate	candidate object	true	candidate details for the assignment

`candidate` object

Parameter	Type	Required	Description
name	string	true	name of the candidate
email	string	true	email of the candidate
phoneNo	string	true	phone no of the candidate

Errors

{
  "status": 400,
  "message": "error string"
}

The intervue.io API uses the following error codes:

Error Code	Meaning
400	Bad Request -- Your request is invalid.
401	Unauthorized -- Your API key is wrong.
403	Forbidden.
404	Not Found -- Requested resource not found.
418	I'm a teapot.
429	Too Many Requests
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.

Introduction

Authentication

To generate API Key

Rate limiting

Only 50 requests are allowed per minute per API key

External Interviews

Schedule external interview

HTTP Request

Body Parameters

Candidate object for upload

Resume object

Timeslot object

Update external interview

HTTP Request

Body Parameters

Candidate object for upload

Resume object

Cancel external interview

HTTP Request

Body Parameters

Get interview details

HTTP Request

Path Parameters

Get hiring roles

HTTP Request

Query Parameters

Get hiring role by ID

HTTP Request

Path Parameters

Get rounds

HTTP Request

Path Parameters

Query Parameters

Get round by ID

HTTP Request

Path Parameters

Get all profiles

HTTP Request

Mock Interviews

Schedule mock interview

HTTP Request

Body Parameters

Candidate object for upload

Resume object

Get rounds and rubrics

HTTP Request

Path Parameters

Get supported profiles

HTTP Request

Response

Get interview information

HTTP Request

Path Parameters

Get candidate information

HTTP Request

Query Parameters

Home Assignments

Get assignments

HTTP Request

Query Parameters

Disable assignment

HTTP Request

Path Parameters

Archive assignment

HTTP Request

Path Parameters

Delete assingment

HTTP Request

Path Parameters

Get skills available

HTTP Request

Get test configuration

HTTP Request

Query Parameters

Create test

HTTP Request

Body Parameters

testConfig object

config object

Send invitations

`testConfig` object

`config` object

`requestedData` object

`requestedBy` object

`cancelData` object

`scheduleData` object

`reportData` object

`verdict` object

`urls` object

`feedback` object

`videoPlaybackData` object

`testData` object

`questions` object

`candidate` object

`testData` object

`questions` object

`candidate` object

`planData` object

`reportData` object

`reminderData` object

`assignmentList` object

`candidate` object

`invitationData` object

`candidate` object