User Management API

With the User Management API you can perform registration operations such as signing up, logging in, and other profile configurations.

This page will go over the common endpoints associated with user management.

Learn more about User Profiles with our Help Center articles.

Authentication

Use the following header parameters for all requests:

Headers
`Authentication` string required	Authentication bearer token or Client ID and Secret See Authentication Guide
`X-IAA-OW-ID` integer required	Organization Workspace ID Header

Authentication

POST

Request Schema
`grantType` string	OAuth Grant Types
`email` string	User's email
`password` string	User's password

Response Properties

`success` boolean	Indicates user succesfully logged in: `true`
`access_token` string	Access token
`refresh_token` string	Refresh token
`scope` string	User access rights
`token_type` string	Token type
`expires_in` integer	Time until token expires
`owId` integer	Organization Workspace ID

JSON
TypeScript

Request Sample
{
  "grantType": "password",
  "email": "pratik.t+ihp@iqm.com",
  "password": "123456"
}

Response 200
{
  "success": true,
  "data": {
    "access_token": "106adb25-37b0-4cab-8381-d682fe7cc3c8",
    "refresh_token": "eac4c1f6-781e-4b04-baff-9c2e415d1f64",
    "scope": "read write",
    "token_type": "bearer",
    "expires_in": 35999,
    "owId": 200001
  }
}

More Responses

Response 400
{
  "success": false,
  "data": {
    "status": "On Hold",
    "reason": "The particular account is kept on hold due to missed payment dates for last 3 months.",
    "supportEmail": "support@iqm.com"
  },
  "errorObjects": [
    {
      "error": "User is not allowed to access provided customer",
      "reason": "User is not associated with any active organization."
    }
  ]
}

Response 403
{
  "success": false,
  "errorObjects": [
    {
      "error": "User doesn't exist or user is not allowed to provided workspace."
    }
  ]
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    content: {
      "application/json": {
        success: boolean;
        data: {
          access_token: string;
          refresh_token: string;
          scope: string;
          token_type: string;

          expires_in: number;

          owId: number;
        };
      };
    };
  };
  400: {
    content: {
      "application/json": {
        success: boolean;
        data: {
          status: string;
          reason: string;
          supportEmail: string;
        };
        errorObjects: {
          error: string;
          reason: string;
        }[];
      };
    };
  };
  403: {
    content: {
      "application/json": {
        success: boolean;
        errorObjects: {
          error: string;
        }[];
      };
    };
  };
};

function Login(): Promise < Responses > {
  const options = {
    method: 'POST',
    url: 'https://api.iqm.com/api/v3/ua/login',
    requestBody: {
      content: {
        "application/json": {
          grantType: `string`,
          email: `string`,
          password: `string`,
        }
      }
    }
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

OAuth Token

POST

This endpoint functions as the main authenticator for external connections.

This API accepts a URL encoded form with different grant types. This endpoint can be used to log in via user password, authorization code or client credentials, or it can be used to refresh an access token.

The API will send an OAuth Compliant Response, as seen in the example Response 200 on the right side column.

Authentication
`Authentication` string required	Client ID and Client Secret
`Content-Type` string required	application/x-www-form-urlencoded

Request Parameters
`grantType` string	OAuth Grant Types: `authorization_code`: log in with redirect URL and client ID and secret `password`: log in with username and password `refresh_token`: obtain a new access token
`refresh_token` string	Refresh token to obtain new access token
`email` string	User's email
`password` string	User's password
`client_id` string	Client ID
`client_secret` string	Client secret

Request Sample (refresh token)
curl -i --location 'https://api.iqm.com/api/v3/ua/oauth/token' \
--header 'accept: application/json, text/plain, */*' \
--header 'Authorization: Basic <Client ID/Client Secret>' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--data-urlencode 'grant_type=refresh_token' \
--data-urlencode 'refresh_token=eac4c1f6-781e-4b04-baff-9c2e415d1f64'

Request Sample (password)
curl -i --location 'https://api.iqm.com/api/v3/ua/oauth/token' \
--header 'accept: application/json, text/plain, */*' \
--header 'Authorization: Basic <Client ID/Client Secret>' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--data-urlencode 'grant_type=password' \
--data-urlencode 'username=user@iqm.com' \
--data-urlencode 'password=<your password>'

Request Sample (auth code)
curl -i --location 'https://api.iqm.com/api/v3/ua/oauth/token' \
--header 'accept: application/json, text/plain, */*' \
--header 'Authorization: Basic <Client ID/Client Secret>' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--data-urlencode 'grant_type=authorization_code' \
--data-urlencode 'client_id=<client_id>' \
--data-urlencode 'client_secret=<client_secret>' \
--data-urlencode 'redirect_uri=http://iqm-authenticator.stage.iqm/showAuthCode'

Response 200
{
  "access_token": "106adb25-37b0-4cab-8381-d682fe7cc3c8",
  "refresh_token": "eac4c1f6-781e-4b04-baff-9c2e415d1f64",
  "scope": "read write",
  "token_type": "bearer",
  "expires_in": 35999
}

User Logout

POST

Log a user out from the API.

Response Properties

`success` boolean	Indicates user succesfully logged out: `true`
`data` string	Success message

JSON
TypeScript

Response 200
{
  "success": true,
  "data": "User logged out successfully."
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    content: {
      "application/json": {
        success: boolean;
        data: string;
      };
    };
  };
};

function Logout(): Promise < Responses > {
  const options = {
    method: 'POST',
    url: 'https://api.iqm.com/api/v3/ua/logout',
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

Change Password

POST

Update a user's password.

Request Schema
`email` string	User's email
`password` string	User's password

Response Properties

`success` boolean	Indicates user's password was succesfully updated: `true`
`data` string	Success message

JSON
TypeScript

Request Sample
{
  "email": "kartik.g@iqm.com",
  "password": "123456"
}

Response 200
{
  "success": true,
  "data": "Password changed successfully."
}

More Responses

Response 403
{
  "success": true,
  "data": {
    "invalidReason": "Reset password link either not valid or it is already processed.",
    "isValid": false
  }
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        data: string;
      };
    };
  };
  403: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        data: {
          invalidReason: string;
          isValid: boolean;
        };
      };
    };
  };
};

function UpdatePassword(): Promise < Responses > {
  const options = {
    method: 'POST',
    url: 'https://api.iqm.com/api/v3/ua/user/update-password',
    requestBody: {
      content: {
        "application/json": {
          email: `string`,
          password: `string`,
        }
      }
    }
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

Reset User Password

POST

Reset your password directly with this endpoint.

Request Schema
`oldPassword` string	User's old password
`newPassword` string	User's new password

Response Properties

`success` boolean	Indicates reset link was succesfully sent: `true`
`data` string	Success message

Request Sample
{
  "oldPassword": "123456",
  "newPassword": "123456789"
}

Response 200
{
  "success": true,
  "data": "Password reset successfully."
}

Reset Password Email

POST

Send a link to reset a user's password to a specified email.

Request Schema
`email` string	User's email

Response Properties

`success` boolean	Indicates reset link was succesfully sent: `true`
`data` string	Success message

JSON
TypeScript

Request Sample
{
  "email": "kartik@iqm.com"
}

Response 200

{
  "success": true,
  "data": "Email with reset password link sent successfully."
}

More Responses

Response 404
{
  "success": false,
  "errorObjects": [
    {
      "error": "The email is not available in the system."
    }
  ]
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        data: string;
      };
    };
  };
  404: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        errorObjects: {
          error: string;
        }[];
      };
    };
  };
};

function ResetPasswordEmail(): Promise < Responses > {
  const options = {
    method: 'POST',
    url: 'https://api.iqm.com/api/v3/ua/user/reset-password',
    requestBody: {
      content: {
        "application/json": {
          email: `string`,
        }
      }
    }
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

Send MFA Code

POST

Generate and send an MFA code to the user associated with the provided organization workspace ID. The code is sent via email or SMS based on user preferences.

Request Schema
`owId` integer	Organization workspace ID

JSON
TypeScript

Request Sample
{
  "owId": 12345
}

Response 200
{
  "success": true,
  "data": "MFA code sent successfully."
}

More Responses

Response 400
{
  "success": false,
  "errorObjects": [
    {
      "error": "Invalid owId or user not found."
    }
  ]
}

Response 422
{
  "success": false,
  "errorObjects": [
    {
      "error": "User MFA settings not configured."
    }
  ]
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    content: {
      "application/json": {
        success: boolean;
        data: string;
      };
    };
  };
};

function SendMfaCode(): Promise < Responses > {
  const options = {
    method: 'POST',
    url: 'https://api.iqm.com/api/v3/ua/auth/mfa/send',
    data: {
      owId: `integer`,
    }
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

Verify MFA Code

POST

Verify a Multi-Factor Authentication (MFA) code (OTP) for the user. Upon successful verification, returns user session details and organization workspace ID.

Request Schema
`otp` string	MFA one-time passcode

Response Properties

`accessToken` string	JWT access token for authenticating API requests
`tokenType` string	Type of the token issued
`expiresIn` integer	Expiration time of the token in seconds
`owId` integer	Organizational workspace ID associated with the user

JSON
TypeScript

Request Sample
{
  "otp": "123456"
}

Response 200
{
  "success": true,
  "data": {
    "accessToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
    "tokenType": "Bearer",
    "expiresIn": 3600,
    "owId": 12345
  }
}

More Responses

Response 401
{
  "success": false,
  "errorObjects": [
    {
      "error": "Invalid or expired MFA code."
    }
  ]
}

Response 403
{
  "success": false,
  "errorObjects": [
    {
      "error": "MFA verification failed."
    }
  ]
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    content: {
      "application/json": {
        success: boolean;
        data: {
          accessToken: string;
          tokenType: string;
          expiresIn: number;
          owId: number;
        };
      };
    };
  };
};

function VerifyMfaCode(): Promise < Responses > {
  const options = {
    method: 'POST',
    url: 'https://api.iqm.com/api/v3/ua/auth/mfa/verify',
    data: {
      otp: `string`,
    }
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

User Details

Get List of Users

GET

Get a list of users and details for a given workspace ID.

Query Parameters

`status` string	Status of user
`searchField` string	Filter results by search field
`limit` integer	Number of entries returned per page, default: `10`
`pageNo` integer	Page number of retrieved data, default: `1`
`sortBy` string	Sorts by ascending (`+`) or descending (`-`), default: `+displayName`

Resource Properties

`userId` integer	Unique user ID
`firstName` string	User's first name
`lastName` string	User's last name
`email` string	User's email
`displayName` string	User's display name
`status` string	User's status
`statusId` integer	Status ID
`userAvatar` string	Image file uploaded for profile
`createdAt` integer	Unix timestamp in Milliseconds when account was created
`uowId` integer	User Organization Workspace ID
`customersCount` integer	Count of Customers assigned to user
`organizationName` string	Organization associated with user
`invitedOn` integer	Unix timestamp in Milliseconds when user was invited to create account
`isOrganizationOwnerUser` boolean	User is owner of Organization (`true`) or not (`false`)
`isModificationAllowed` boolean	User is allowed to modify (`true`) or not (`false`)
`invitedByUserName` string	Name of user that invited user
`invitedByUserEmail` string	Email of user that invited user
`isAssignActionAllowed` boolean	User is allowed to assign (`true`) or not (`false`)

JSON
TypeScript

Response 200
{
  "success": true,
  "data": {
    "data": [
      {
        "userId": 7130,
        "firstName": "sample adv user -2",
        "lastName": "2",
        "email": "sample-user@iqm.com",
        "displayName": "sample adv user - 2",
        "status": "active",
        "statusId": 1,
        "userAvatar": "https://iqm-web-assets-c92d6b6cbde1-stage.s3.amazonaws.com/avatar/K2.png",
        "createdAt": 1705452608000,
        "uowId": 119592,
        "customersCount": 0,
        "organizationName": "Adv Acc 1",
        "invitedOn": 1705452608000,
        "isOrganizationOwnerUser": false,
        "isModificationAllowed": true,
        "invitedByUserName": "User 2",
        "invitedByUserEmail": "user2@iqm.com",
        "isAssignActionAllowed": true
      },
      {
        "userId": 7131,
        "firstName": "sample-adv-user-3",
        "email": "sample-user1@iqm.com",
        "displayName": "sample-adv-user-3",
        "status": "invited",
        "statusId": 3,
        "userAvatar": "https://iqm-web-assets-c92d6b6cbde1-stage.s3.amazonaws.com/avatar/KH.png",
        "createdAt": 1705466349000,
        "uowId": 119595,
        "customersCount": 0,
        "organizationName": " Adv Acc",
        "invitedOn": 1705466349000,
        "isOrganizationOwnerUser": false,
        "isModificationAllowed": true,
        "invitedByUserName": "User 1",
        "invitedByUserEmail": "user1@iqm.com",
        "isAssignActionAllowed": true
      },
    ],
    "totalRecords": 6,
    "filteredRecords": 2
  }
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        data: {
          data: {
            userId: number;
            firstName: string;
            lastName: string;
            email: string;
            displayName: string;
            status: string;
            statusId: string;
            userAvatar: string;
            createdAt: number;
            uowId: number;
            customersCount: number;
            organizationName: string;
            invitedOn: number;
            isOrganizationOwnerUser: boolean;
            isModificationAllowed: boolean;
            invitedByUserName: string;
            invitedByUserEmail: string;
            isAssignActionAllowed: boolean;
          }[];
          totalRecords: number;
          filteredRecords: number;
        }
      }
    };
  };
};

function getUsersList(): Promise < Responses > {
  const options = {
    method: 'GET',
    url: 'https://api.iqm.com/api/v3/ua/users/list',
    params: {
      query?: {
        status?: `string`,
        pageNo?: `number`,
        limit?: `number`,
        sortBy?: `string`,
        searchField?: `string`,
      },
    },
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

Basic User List

GET

Returns a paginated list of users with basic details. Supports filtering by search term, status, MFA settings, and sorting.

Query Parameters
`searchField` string	Search by user ID, first name, last name, display name, or email
`pageNo` integer	Page number (starts from 1)
`noOfEntries` integer	Number of entries per page
`sortBy` string	Sort field: `+displayName` (asc) or `-displayName` (desc)
`statusIds` array of integers	Filter by status IDs (e.g., `1` for active, `2` for invited)
`mfaEnabled` boolean	Filter by MFA enabled status
`includeMfaMeta` boolean	Include MFA metadata in the response

Response Properties

totalRecords
integer Total number of records

filteredRecords
integer Number of records matching the filter

mfaEnabledCount
integer Count of users with MFA enabled

mfaDisabledCount
integer Count of users with MFA disabled

usersBasicList
array of objects List of users

usersBasicList object properties

`userId` integer	User ID
`firstName` string	First name
`lastName` string	Last name
`email` string	Email address
`displayName` string	Display name
`statusId` integer	User status ID
`userProfileUrl` string	Profile picture URL
`createdAt` string	Timestamp when the user was created
`mfaEnabled` boolean	Whether MFA is enabled for the user
`canToggleMfa` boolean	Whether the user can toggle their MFA setting

JSON
TypeScript

Response 200
{
  "success": true,
  "data": {
    "totalRecords": 120,
    "filteredRecords": 2,
    "mfaEnabledCount": 10,
    "mfaDisabledCount": 5,
    "usersBasicList": [
      {
        "userId": 12345,
        "firstName": "John",
        "lastName": "Doe",
        "email": "john.doe@example.com",
        "displayName": "John Doe",
        "statusId": 1,
        "userProfileUrl": "https://example.com/profile.jpg",
        "createdAt": "2024-01-01T12:00:00Z",
        "mfaEnabled": true,
        "canToggleMfa": true
      }
    ]
  }
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface UserBasic {
  userId: number;
  firstName: string;
  lastName: string;
  email: string;
  displayName: string;
  statusId: number;
  userProfileUrl: string;
  createdAt: string;
  mfaEnabled: boolean;
  canToggleMfa: boolean;
}

interface Responses {
  200: {
    content: {
      "application/json": {
        success: boolean;
        data: {
          totalRecords: number;
          filteredRecords: number;
          mfaEnabledCount: number;
          mfaDisabledCount: number;
          usersBasicList: UserBasic[];
        };
      };
    };
  };
};

function GetBasicUserList(params?: {
  searchField?: string;
  pageNo?: number;
  noOfEntries?: number;
  sortBy?: string;
  statusIds?: number[];
  mfaEnabled?: boolean;
  includeMfaMeta?: boolean;
}): Promise < Responses > {
  const options = {
    method: 'GET',
    url: 'https://api.iqm.com/api/v3/ua/users/basic/list',
    params,
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

GET

Retrieve a list of users who can share or have access to a specific customer, for assignment or sharing purposes.

Query Parameters
`owId` integer	Customer organization workspace ID
`searchField` string	Search term to filter users
`pageNo` integer	Page number (default: 1)
`limit` integer	Number of records per page (default: 100)

Response Properties

totalRecords
integer Total number of records

filteredRecords
integer Number of records matching the filter

data
array of objects List of users

data object properties

`userId` integer	User ID
`owId` integer	Organization workspace ID
`uowId` integer	User organization workspace ID
`displayName` string	Display name
`email` string	Email address
`status` integer	User status
`customerAssigned` boolean	Whether the user is already assigned to this customer

JSON
TypeScript

Response 200
{
  "success": true,
  "data": {
    "totalRecords": 50,
    "filteredRecords": 2,
    "data": [
      {
        "userId": 12345,
        "owId": 67890,
        "uowId": 112233,
        "displayName": "John Doe",
        "email": "john.doe@example.com",
        "status": 1,
        "customerAssigned": false
      }
    ]
  }
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface UserShareEntry {
  userId: number;
  owId: number;
  uowId: number;
  displayName: string;
  email: string;
  status: number;
  customerAssigned: boolean;
}

interface Responses {
  200: {
    content: {
      "application/json": {
        success: boolean;
        data: {
          totalRecords: number;
          filteredRecords: number;
          data: UserShareEntry[];
        };
      };
    };
  };
};

function GetUsersForCustomerSharing(params: {
  owId: number;
  searchField?: string;
  pageNo?: number;
  limit?: number;
}): Promise < Responses > {
  const options = {
    method: 'GET',
    url: 'https://api.iqm.com/api/v3/ua/users/list/share-customer',
    params,
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

Get User Profile Details

GET

Get user profile details and parent organization hierarchy.

Resource Properties

uowId
integer User Organization Workspace ID

status
string User's status

invoiceId
integer User's invoice ID

firstName
string User's first name

lastName
string User's last name

displayName
string User's display name

userAvatar
string Image file uploaded for profile

email
string User's email

organizationName
string Organization associated with user

organizationLogo
string Organization associated with user

isOwnerUser
boolean Indicates user is owner: true

isPlatformOwnerOrg
boolean Indicates user is platform owner (super user): true

isWorkspaceOwnerOrg
boolean Indicates user is owner (Workspace user): true

isCampaignAppOwner
boolean Indicates user is owner of Campaign App (super user): true

isBetaUser
boolean Indicates user is beta user: true

allowExtendedReportDuration
integer

parentOrganization
object Parent Organization details

parentOrganization object properties

`owId` integer	Organization Workspace ID
`organizationName` string	Organization associated with user
`workspaceDomain` string	Workspace domain
`isAccess` boolean	Indicates logged-in user has Customer management access of given Customer Organization: `true`
`parentOrganization` object	Parent Organization details

organizationTimezone
integer Organization timezone

JSON
TypeScript

Response 200
{
  "success": true,
  "data": {
    "owId": 200002,
    "status": 1,
    "invoiceId": 283,
    "firstName": "your first name",
    "lastName": "1",
    "displayName": "display Name",
    "userAvatar": "https://iqm-web-assets-c92d6b6cbde1-stage.s3.amazonaws.com/user-profile/1/1651537740179.jpg",
    "email": "yourEmail@yahoo.com",
    "organizationName": "AdAgency 1",
    "organizationLogo": "https://d3jme5si7t6llb.cloudfront.net/logo/iqm.png",
    "isOwnerUser": false,
    "isPlatformOwnerOrg": false,
    "isWorkspaceOwnerOrg": true,
    "isCampaignAppOwner": false,
    "isBetaUser": true,
    "allowExtendedReportDuration": 1,
    "parentOrganization": {
      "owId": 200001,
      "organizationName": "AdAgency 2",
      "workspaceDomain": "yourDomain.com",
      "isAccess": true
    },
    "organizationTimezone": 29
  }
}

See TypeScript Prerequisites for usage.

User Config Details

GET

Get user configuration details for the current user.

Resource Properties

marginAccess
boolean Indicates if the user has access to margin trading: true

Response 200
{
  "success": true,
  "data": {
    "marginAccess": true
  }
}

User Management

Send User Invitation

POST

Any Customer or Organization can send invitations to one or more users by providing their names and emails.

Request Schema
`email` string	User's email
`name` string	User's name

Response Properties

`success` boolean	Indicates invite was succesfully sent: `true`
`data` string	Success message

JSON
TypeScript

Request Sample
{
  "email": "shraddha.p@iqm.com",
  "name": "Shradda Patel"
}

Response 200
{
  "success": true,
  "data": "1 invitations sent successfully."
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        data: string;
      };
    };
  };
};

function SendUserInvitations(): Promise < Responses > {
  const options = {
    method: 'POST',
    url: 'https://api.iqm.com/api/v3/ua/user/invite',
    requestBody: {
      content: {
        "application/json": [
          {
            email: `string`,
            name: `string`,
          }
        ]
      }
    }
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

Resend User Invitation

POST

Resend an invitation to a user within an organization workspace.

Request Schema
`userId` integer	User ID
`email` string	User's email address
`uowId` integer	User organization workspace ID

JSON
TypeScript

Request Sample
{
  "userId": 1001,
  "email": "john.doe@example.com",
  "uowId": 2001
}

Response 200
{
  "success": true,
  "data": "Invitation resent successfully."
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    content: {
      "application/json": {
        success: boolean;
        data: string;
      };
    };
  };
};

function ResendUserInvitation(body: {
  userId: number;
  email: string;
  uowId: number;
}): Promise < Responses > {
  const options = {
    method: 'POST',
    url: 'https://api.iqm.com/api/v3/ua/user/re-invite',
    data: body,
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

POST

A user/Customer can sign up and create a password to access the API.

Request Schema
`email` string	User's email
`password` string	User's password

Response Properties

`success` boolean	Indicates user was succesfully signed up: `true`
`access_token` string	Access token
`refresh_token` string	Refresh token
`scope` string	User access rights
`token_type` string	Token type
`expires_in` integer	Time until token expires

JSON
TypeScript

Request Sample
{
    "email": "kartik.g@iqm.com",
    "password": "123456"
}

Response 200
{
  "success": true,
  "data": {
    "access_token": "d90fa7de-534c-4652-ad8f-c4f6f70461ac",
    "refresh_token": "2e379c6f-959d-498f-8319-ff13ebef6bfe",
    "scope": "read write",
    "token_type": "bearer",
    "expires_in": 35999
  }
}

More Responses

Response 403
{
  "success": false,
  "errorObjects": [
    {
      "error": "User is not allowed to create a password.",
      "reason": "User is not invited or invitation is processed or invitation is expired."
    }
  ]
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        data: {
          access_token: string;
          refresh_token: string;
          scope: string;
          token_type: string;

          expires_in: number;
        };
      };
    };
  };
  403: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        errorObjects: {
          error: string;
          reason: string;
        }[];
      };
    };
  };
};

function UserSign-up/PasswordCreation(): Promise < Responses > {
  const options = {
    method: 'POST',
    url: 'https://api.iqm.com/api/v3/ua/sign-up',
    requestBody: {
      content: {
        "application/json": {
          email: `string`,
          password: `string`,
        }
      }
    }
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

Update User Profile

PATCH

Update a user's profile display name and avatar.

Request Schema
`displayName` string	User Name
`userAvatar` string	If `removeUserProfile` set to `true`, can remain null, otherwise: Image file uploaded for profile
`removeUserProfile` boolean	default: `false` To remove profile image `true`

Response Properties

`success` boolean	Indicates user's profile was succesfully updated: `true`
`userAvater` string	User avatar
`message` string	Success message

JSON
TypeScript

Response 200
{
    "success": true,
    "data": {
        "userAvatar": "https://iqm-web-assets-c92d6b6cbde1-stage.s3.amazonaws.com/user-profile/444.jpg",
        "message": "Profile updated successfully."
    }
}

More Responses

Response 422
{
    "success": false,
    "errorObjects": [
        {
            "error": "Profile image should not be more than 3 MB"
        }
    ]
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        data: {
          userAvatar: string;
          message: string;
        };
      };
    };
  };

  422: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        errorObjects: {
          error: string;
        }[];
      };
    };
  };
};

function UpdateUserProfile(): Promise < Responses > {
  const options = {
    method: 'PATCH',
    url: 'https://api.iqm.com/api/v3/ua/user/update-profile',
    requestBody?: {
      content: {
        "application/x-www-form-urlencoded": {
          displayName: `string`,
          userAvatar: `string`,
          removeUserProfile: `boolean`,
        }
      }
    }
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

Update User Status

PUT

Update a user's status.

Request Schema
`uowId` integer	User's Organization Workspace ID
`status` integer	Updated Status ID
`statusReason` string	Reason for status change

Response Properties

`success` boolean	Indicates if the status was updated successfully
`data` string	Success message

Request Sample
{
  "uowId": 166,
  "status": 4,
  "statusReason": "Payment overdue for last 3 months"
}

Response 200
{
    "success": true,
    "data": "User status updated successfully."
}

Enable MFA

POST

Enable Multi-Factor Authentication for one or more users by user ID.

Request Schema
`userIds` array of integers	User IDs to enable MFA for

Response Properties

`mfaEnabledSuccessfully` array of integers	User IDs for which MFA was enabled successfully
`mfaEnablingFailed` array of integers	User IDs for which MFA enabling failed

JSON
TypeScript

Request Sample
{
  "userIds": [123, 345]
}

Response 200
{
  "success": true,
  "data": {
    "mfaEnabledSuccessfully": [123, 345],
    "mfaEnablingFailed": []
  }
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    content: {
      "application/json": {
        success: boolean;
        data: {
          mfaEnabledSuccessfully: number[];
          mfaEnablingFailed: number[];
        };
      };
    };
  };
};

function EnableMfa(): Promise < Responses > {
  const options = {
    method: 'POST',
    url: 'https://api.iqm.com/api/v3/ua/mfa/enable',
    data: {
      userIds: `integer[]`,
    }
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

Disable MFA

POST

Disable Multi-Factor Authentication for one or more users by user ID.

Request Schema
`userIds` array of integers	User IDs to disable MFA for

Response Properties

`mfaDisabledSuccessfully` array of integers	User IDs for which MFA was disabled successfully
`mfaDisablingFailed` array of integers	User IDs for which MFA disabling failed

JSON
TypeScript

Request Sample
{
  "userIds": [123, 345]
}

Response 200
{
  "success": true,
  "data": {
    "mfaDisabledSuccessfully": [123, 345],
    "mfaDisablingFailed": []
  }
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    content: {
      "application/json": {
        success: boolean;
        data: {
          mfaDisabledSuccessfully: number[];
          mfaDisablingFailed: number[];
        };
      };
    };
  };
};

function DisableMfa(): Promise < Responses > {
  const options = {
    method: 'POST',
    url: 'https://api.iqm.com/api/v3/ua/mfa/disable',
    data: {
      userIds: `integer[]`,
    }
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

User Application Access

Allowed Applications List

GET

Get a list of all applications a user can be granted access to.

Response Properties

`appId` integer	Bundle ID for app request
`appName` string	App name
`appIcon` string	App icon URL
`appUrl` string	App URL

Response 200
{
    "success": true,
    "data": [
        {
            "appId": 2,
            "appName": "Dashboard",
            "appIcon": "logo/dashboard.png",
            "appUrl": "/dashboard"
        },
        {
            "appId": 7,
            "appName": "Campaigns",
            "appIcon": "logo/campaigns.png",
            "appUrl": "/campaigns"
        },
        {
            "appId": 9,
            "appName": "Creatives",
            "appIcon": "logo/creatives.png",
            "appUrl": "/creatives"
        },
        {
            "appId": 8,
            "appName": "Audiences",
            "appIcon": "logo/audiences.png",
            "appUrl": "/audiences"
        },
        {
            "appId": 10,
            "appName": "Inventory",
            "appIcon": "logo/inventory.png",
            "appUrl": "/inventory"
        },
        {
            "appId": 4,
            "appName": "Bid Model",
            "appIcon": "logo/bid-model.png",
            "appUrl": "/bidmodel"
        },
        {
            "appId": 3,
            "appName": "Reports",
            "appIcon": "logo/reports.png",
            "appUrl": "/reports"
        },
        {
            "appId": 5,
            "appName": "Organization",
            "appIcon": "logo/organization.png",
            "appUrl": "/organization"
        },
        {
            "appId": 6,
            "appName": "My Profile",
            "appIcon": "logo/my-profile.png",
            "appUrl": "/accounts"
        },
        {
            "appId": 17,
            "appName": "Insights",
            "appIcon": "logo/insights.png",
            "appUrl": "/insights"
        },
        {
            "appId": 19,
            "appName": "Planner",
            "appIcon": "logo/planner.png",
            "appUrl": "/planner"
        }
    ]
}

User App Access List

GET

See what applications a user has access to, use query parameters to filter results.

Query Parameters
`uowId` integer	User Organization Workspace ID
`searchField` string	Filter results by search field
`limit` integer required	Number of entries returned per page, default: `10`
`pageNo` integer required	Page number of retrieved data, default: `1`
`sortBy` string	Sorts by ascending (`+`) or descending (`-`), default: `+appName`

Response Properties

`success` boolean	Indicates app access was succesfully retrieved: `true`
`appId` integer	Bundle ID for app request
`appName` string	App name
`appOwner` string	App owner
`appType` string	App type

JSON
TypeScript

Response 200
{
  "success": true,
  "data": {
    "data": [
      {
        "appId": 7,
        "appName": "Campaigns",
        "appOwner": "IQM Corporation",
        "appType": "Default App"
      },
      {
        "appId": 11,
        "appName": "Conversions",
        "appOwner": "IQM Corporation",
        "appType": "Default App"
      }
    ],
    "totalRecords": 2,
    "filteredRecords": 2
  }  
}

More Responses

Response 422
{
  "success": false,
  "errorObjects": [
    {
      "error": "Invalid sortBy value."
    }
  ]
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        data: {
          data: {
            appId: number;
            appName: string;
            appOwner: string;
            appType: string;
          }[];
          totalRecords: number;
          filteredRecords: number;
        };
      };
    };
  };
  422: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        errorObjects: {
          error: string;
        }[];
      };
    };
  };
};

function GetUserApplicationaccesslist(): Promise < Responses > {
  const options = {
    method: 'GET',
    url: 'https://api.iqm.com/api/v3/ua/user/applications/list',
    params: {
      query?: {
        uowId?: `number`,
        pageNo?: `number`,
        limit?: `number`,
        sortBy?: `string`,
        searchField?: `string`,
      },
    },
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

Add App Access for User

POST

Grant a user access to specified apps.

Request Schema
`userID` integer	User's ID
`appIds` string	Application ID
`accessLevel` string	Level of access granted to user

Response Properties

`success` boolean	Indicates access was succesfully granted: `true`
`data` string	Success message

JSON
TypeScript

Request Sample
{
  "userId": 431,
  "appIds": "1",
  "accessLevel": "Full"
}

Response 200
{
  "success": true,
  "data": "Application access added successfully."
}

More Responses

Response 403
{
  "success": false,
  "errorObjects": [
    {
      "error": "User doesn't exist or user is not part of the Organization."
    }
  ]
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        data: string;
      };
    };
  };
  403: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        errorObjects: {
          error: string;
        }[];
      };
    };
  };
};

function AddAppaccessforUser(): Promise < Responses > {
  const options = {
    method: 'POST',
    url: 'https://api.iqm.com/api/v3/ua/user/application/add',
    requestBody: {
      content: {
        "application/json": {
          userId: `number`,
          appIds: `string`,
          accessLevel: `string`,
        }
      }
    }
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

Revoke App Access for User

POST

Revoke a user's access to specified apps.

Request Schema
`owId` integer	User's Organization Workspace ID
`appIds` string	Application ID

Request Sample
{
  "owId": 431,
  "appIds": "1"
}

Response 200
{
  "success": true,
  "data": "Application access revoked successfully."
}

Remaining Applications

GET

Retrieve the list of applications that can still be assigned to a user.

Query Parameters
`uowId` integer	User organization workspace ID

Response Properties

`applicationId` integer	Application ID
`applicationName` string	Application name
`applicationCode` string	Application code

JSON
TypeScript

Response 200
{
  "success": true,
  "data": [
    {
      "applicationId": 1,
      "applicationName": "Google Ads",
      "applicationCode": "GA"
    },
    {
      "applicationId": 2,
      "applicationName": "Facebook Ads",
      "applicationCode": "FB"
    }
  ]
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    content: {
      "application/json": {
        success: boolean;
        data: {
          applicationId: number;
          applicationName: string;
          applicationCode: string;
        }[];
      };
    };
  };
};

function GetRemainingApplications(params: {
  uowId: number;
}): Promise < Responses > {
  const options = {
    method: 'GET',
    url: 'https://api.iqm.com/api/v3/ua/user/remaining-applications',
    params,
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

Validations

Validate User Invite

POST

The invited user will receive an email with a link and a hash which can be validated.

Request Schema
`inviteHash` string	Unique invite hash sent to invited user

Response Properties

isExpired
boolean Indicates invite hash is expired: true

JSON
TypeScript

Request Sample
{
    "inviteHash": "8HQfsQcychjhvCmuuiFvVCIgqq9cJG/gh6HgmPZXxGE4od7a7tsMmh/O9+ia2Lw0FOelX3h8jTKJXR+0hUAkGXYA0cIITS13BxyrWoeBmRTnWTKxHtS+Ff41POwt/yDMY2iHXUsG86ehmWeeIi3HNMikhH5yY6BvNFnEfxq3zIdiouD3Fp/loPO9qazxU1qxZvNOOv8FZEZTzORVnJ8+ADjyZ/Zjs1dNhSFE"
}

Response 200
{
  "success": true,
  "data": {
    "isExpired": true
  }
}

More Responses

Response 422
{
  "success": false,
  "errorObjects": [
    {
      "error": "Provided invitation has is incorrect.",
      "field": "inviteHash"
    }
  ]
}

See TypeScript Prerequisites for usage.

import {
  getInstance
} from "prerequisites"

const axios = getInstance();

interface Responses {
  200: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        data: {
          isExpired: boolean;
        };
      };
    };
  };
  422: {
    headers: {
      [name: string]: unknown;
    };
    content: {
      "application/json": {
        success: boolean;
        errorObjects: {
          error: string;
          field: string;
        }[];
      };
    };
  };
};

function ValidateInvite(): Promise < Responses > {
  const options = {
    method: 'POST',
    url: 'https://api.iqm.com/api/v3/ua/invite/validate',
    requestBody: {
      content: {
        "application/json": {
          inviteHash: `string`,
        }
      }
    }
  };

  return axios.request(options).then(({ data }: { data: Responses }) => data);
}

Validate Password Reset Hash

POST

Validate the password reset hash sent to a user's email.

Request Schema
`resetHash` string	Unique reset hash sent to user

Response Properties

`resetEmail` string	User's email
`isValid` boolean	Indicates reset hash is valid: `true`
`invalidReason` string	Reason why reset hash is invalid

Request Sample
{
  "resetHash": "8HQfsQcychjhvCmuuiFvVCIgqq9cJG/gh6HgmPZXxGE4od7a7tsMmh/O9+ia2Lw0FOelX3h8jTKJXR+0hUAkGXYA0cIITS13BxyrWoeBmRTnWTKxHtS+Ff41POwt/yDMY2iHXUsG86ehmWeeIi3HNMikhH5yY6BvNFnEfxq3zIdiouD3Fp/loPO9qazxU1qxZvNOOv8FZEZTzORVnJ8+ADjyZ/Zjs1dNhSFE"
}

Response 200
{
  "success": true,
  "data": {
    "resetEmail": "<user@example.com>",
    "isValid": true
  }
}

Validate User Email

POST

Check if a user's email is already registered.

Request Schema
`email` string	User's email
`workspaceDomain` string	Workspace domain associated with user

Response Properties

`isValid` boolean	Indicates email is already registered: `true`
`owId` integer	Organization Workspace ID associated with user
`isWorkspaceAllowed` boolean	Indicates if user is allowed in the organization workspace: `true`

Request Sample
{
  "email": "<user@example.com>",
  "workspaceDomain": "<workspace.example.com>"
}

Response 200
{
  "success": true,
  "data": {
    "isValid": true,
    "owId": 123,
    "isWorkspaceAllowed": true
  }
}

Validate Workspace Domain

POST

Validate the workspace domain associated with a user.

Request Schema
`email` string	User's email
`workspaceDomain` string	Workspace domain to validate

Response Properties

success
boolean Indicates workspace domain is valid: true

Request Sample
{
  "email": "user@ihp.com",
  "workspaceDomain": "app.stage.inhousebuying.com"
}

Response 200
{
  "success": true
}

POST

Check if a user's email is already registered for signup.

Request Schema
`email` string	User's email

Response Properties

`userName` string	User name
`isNewUser` boolean	Indicates user is new to platform: `true`
`isOrganizationOwnerUser` boolean	Indicates user is organization owner: `true`

Request Sample
{
  "email": "<user@example.com>"
}

Response 200
{
  "success": true,
  "data": {
    "userName": "userName",
    "isNewUser": false,
    "isOrganizationOwnerUser": false
  }
}

Validate User Password

POST

Validate the user's password.

Request Schema
`password` string	User's password

Response Properties

isValid
boolean Indicates password is valid: true

Request Sample
{
  "password": "userPassword"
}

Response 200
{
  "success": true,
  "data": {
    "isValid": false
  }
}

Have a question?

Ask the Community

Was this page helpful?

Authentication​

Authentication​

Login​

OAuth Token​

User Logout​

Change Password​

Reset User Password​

Reset Password Email​

Send MFA Code​

Verify MFA Code​

User Details​

Get List of Users​

Basic User List​

Users for Customer Sharing​

Get User Profile Details​

User Config Details​

User Management​

Send User Invitation​

Resend User Invitation​

User Sign-Up​

Update User Profile​

Update User Status​

Enable MFA​

Disable MFA​

User Application Access​

Allowed Applications List​

User App Access List​

Add App Access for User​

Revoke App Access for User​

Remaining Applications​

Validations​

Validate User Invite​

Validate Password Reset Hash​

Validate User Email​

Validate Workspace Domain​

Validate User Email for Signup​

Validate User Password​

Authentication

Authentication

Login

OAuth Token

User Logout

Change Password

Reset User Password

Reset Password Email

Send MFA Code

Verify MFA Code

User Details

Get List of Users

Basic User List

Users for Customer Sharing

Get User Profile Details

User Config Details

User Management

Send User Invitation

Resend User Invitation

User Sign-Up

Update User Profile

Update User Status

Enable MFA

Disable MFA

User Application Access

Allowed Applications List

User App Access List

Add App Access for User

Revoke App Access for User

Remaining Applications

Validations

Validate User Invite

Validate Password Reset Hash

Validate User Email

Validate Workspace Domain

Validate User Email for Signup

Validate User Password