Sign Up a New Customer

About IQM Customers

Customers can be invited or signed up to the IQM platform as Workspaces or Advertisers.

Workspaces have app access and permissions that allow them manage multiple accounts within their agency on the same platform.
Advertisers are individually managed and may have limited permissions or app access. Insertion Orders and Campaigns are created at the Advertiser level.

For an overview of IQM's organization hierarchy review the IQM Platform Overview.

More Resources

Before You Begin

To create a new Customer, the following are required:

An Account On the IQM platform
- See Getting Started section to create an account and request a Client ID and Client Secret
User must have login access to the Organization and access to the Customer app

Log In

POST /api/v3/ua/login

To log in, the Authentication: Basic header is required. The Login API returns an OAuth-compliant response with an Organization Workspace ID (owId), a unique identifier for each Organization. This ID will be used for any further API communications.

For further information see the complete Login API Documentation.

Headers
`Authentication` string required	Authentication bearer token See Authentication Guide

Request Schema
`grantType` string required	OAuth Grant Types
`email` string required	User account email
`password` string required	User account password

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 page 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://app.iqm.com/api/v3/ua/login',
    requestBody: {
      content: {
        "application/json": {
          email: `string`,
          password: `string`,
        }
      }
    }
  };

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

Authentication

Use the following header parameters for all requests after logging in:

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

This Tutorial will cover how to sign up or invite a new Customer using the IQM API.

A new Customer can be onboarded in two different ways:

An existing Organization can invite a Customer to the platform.
A new customer can sign up and be approved by an existing Organization on the platform.

Once a Customer has accepted their invitation and the onboarding process is complete other Customer actions can be performed. This Tutorial will cover a few examples. The rest of the possible Customer actions are documented in the Workspace API.

The following diagram outlines the two courses of action covered in this Tutorial:

Invite a Customer

POST /api/v3/ua/customer/invite

An Organization already a part of the IQM platform can initiate an invite to create a new Organization for their Customer.

Up to 10 invites are allowed per request.

Upon invite Customer status will be invited. Once the invitation is accepted the Customer's status will be active and the onboarding process will be complete.

Request Schema

email
string Customer email

name
string Customer name

password
string Customer password

onwerUserName
string Customer owner

verticalId
integer Vertical Type ID

logoUrl
string Logo URL

customerOperationDetails
object Customer operations details (Workspace only)

customerOperationDetails object properties

`customerTypeId` integer	Customer Type ID
`customerPaymentTypeId` integer	Customer Payment Type ID
`countryId` integer	Country ID
`adOpsAssigneeUserIds` array of integers	User IDs assigned by the IQM AdOps Team
`sellerAssigneeUserIds` array of integers	User IDs assigned by the client/seller team
`labelIds` array of integers	Label ID

Response Properties

`successfulEmails` array of strings	Invites succesfully sent to specified emails
`failedEmails` array of strings	Invites failed to send to specified emails
`message` string	Success message

JSON
TypeScript

Request Sample
[
  {
    "email": "user1@iqm.com",
    "name": "ORG - 1",
    "password": "password@123",
    "ownerUserName": "User-1",
    "verticalId": 1,
    "logoUrl": "https://d3jme5si7t6llb.cloudfront.net/assets/202753/Pd7Xx26_1721991655891.png",
    "customerOperationDetails": {
      "customerTypeId": 2,
      "customerPaymentTypeId": 2,
      "countryId": 30100001,
      "adOpsAssigneeUserIds": [],
      "sellerAssigneeUserIds": [
        7184
      ],
      "labelIds": [
        7,
        8,
        9
      ]
    }
  }
]

Response 200
{
"success": true,
"data": {
  "successfulEmails": [
    "user1.g@iqm.com"
  ],
  "failedEmails": [
    "user2.p@iqm.com"
  ],
  "message": "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: {
          successfulEmails: string[];
          failedEmails: string[];
          message: string;
        }
      }
    };
  };
};

function sendInvitations(): Promise < Responses > {
  const options = {
    method: 'POST',
    url: 'https://app.iqm.com/api/v3/ua/customer/invite',
    requestBody: {
      content: {
        "application/json": [
          {
            id?: `number`,
            invitedUserOWId?: `number`,
            email?: `string`,
            password?: `string`,
            name?: `string`,
            ownerUserName?: `string`,
            owId?: `number`,
            uowId?: `number`,
            modifiedByUOWId?: `number`,
            status?: `number`,
            expiresAt?: `number`,
            modifiedAt?: `string`,
            invitationUserType?: `string`,
            verticalId?: `number`,
            logoUrl?: `string`,
            serviceType?: `number`,
            customerOperationDetails?: {
              customerTypeId?: `number`,
              customerPaymentTypeId?: `number`,
              countryId?: `number`,
              createdByUowId?: `number`,
              modifiedByUowId?: `number`,
              adOpsAssigneeUserIds?: `array of numbers`,
              sellerAssigneeUserIds?: `array of numbers`,
              labelIds?: `array of numbers`,
            }
          }
        ]
      }
    }
  };

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

POST /api/v3/ua/customer/signup

A Customer Organization can register itself using the signup API. On signup, the Customer status will be pending. This will trigger the parent Organization to approve the new Customer signup (see next section).

Once approved, an invitation email will be sent to complete the registration process, and the Customer status will update to active.

Request Schema
`email` string	Customer email
`organizationName` string	Customer Organization name
`userName` string	Customer user name
`industry` integer	Industry ID
`companySize` integer	Company Size Type ID
`mediaBudget` integer	Media Budget ID
`budgetSpent` integer	Budget spent

Response Properties

data
string Success message

JSON
TypeScript

Request Sample
{
    "email": "email@domain.com",
    "organizationName": "Organisation Name",
    "userName": "User Name",
    "industry": 1,
    "companySize": 2,
    "mediaBudget": 3,
    "budgetSpent": 2000
}

Response 200
{
    "success": true,
    "data": "Customer sign up requested 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 Customersignup(): Promise<Responses> {
  const options = {
    method: 'POST',
    url: 'https://app.iqm.com/api/v3/ua/customer/signup',
    requestBody: {
      content: {
        "application/json": {
          email: `string`,
          organizationName: `string`,
          userName: `string`,
          industry: `number`,
          companySize: `number`,
          mediaBudget: `number`,
          budgetSpent: `number`,
        }
      }
    }
  };

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

Approve a Customer

PATCH /api/v3/ua/customer/approve

Approve a Customer and add app access.

Request Schema
`owId` integer	Organization Workspace ID
`appIds` string	Comma separated Application IDs to add or revoke Customer access to

Response Properties

data
string Success message

JSON
TypeScript

Request Sample
{
    "owId": 134562,
    "appIds": "2,5,6,7,9,10,11"
}

Response 200
{
  "success": true,
  "data": "Customer approved successfully."
}

More Responses

Response 403
{
  "success": false,
  "errorObjects": [
    {
      "error": "User is not allowed to access provided customer"
    }
  ]
}

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 Approvecustomer(): Promise<Responses> {
  const options = {
    method: 'PATCH',
    url: 'https://app.iqm.com/api/v3/ua/customer/approve',
    requestBody: {
      content: {
        "application/json": {
          owIds: `number`,
          appIds: `string`,
        }
      }
    }
  };

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

More Customer Actions

Assign Customer to User

POST /api/v3//ua/user/customer/assign

Assign a Customer to an existing user.

Request Schema
`owIds` string	Comma separated OW IDs to assign to user
`uowIds` string	Comma separated user IDs to assign Customers to

Response Properties

data
string Success message

JSON
TypeScript

Request Sample
{
    "owIds": "170,58,167,900",
    "uowIds": "166"
}

Response 200
{
    "success": true,
    "data": "Added Customer association to User 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;
        errorObjects: {
          error: string;
        }[];
        data: {
          successfulCustomerIds: number[];
        };
      };
    };
  };
}

function AssignCustomerstoUser(): Promise<Responses> {
  const options = {
    method: 'POST',
    url: 'https://app.iqm.com/api/v3/ua/customer/assign',
    requestBody: {
      content: {
        "application/json": {
          owIds: `string`,
          uowIds: `string`,
        }
      }
    }
  };

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

Add Customer App Access

POST /api/v3/ua/customer/application/add

Add Customer access to specified apps.

Request Schema
`owId` integer	Organization Workspace ID
`appIds` string	Comma separated Application IDs to add or revoke Customer access to
`accessLevel` string	Gives Customer `full` or `limited` access to added applications

Response Properties

data
string Success message

JSON
TypeScript

Request Sample
{
    "owId": 2,
    "appIds": "1,2",
    "accessLevel": "Full"
}

Response 200
{
    "success": true,
    "data": "Application access added 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 AddAppaccessforCustomer(): Promise<Responses> {
  const options = {
    method: 'POST',
    url: 'https://app.iqm.com/api/v3/ua/customer/application/add',
    requestBody: {
      content: {
        "application/json": {
          owId: `number`,
          appIds: `string`,
          accessLevel: `string`
        }
      }
    }
  };

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

Add Payment for Customer

POST /api/v3/fa/customer/payment/add

Request Schema
`owId` integer	Organization Workspace ID
`paymentAmount` integer	Payment amount
`paymentDate` string	Payment date in YYYY-MM-DD format
`paymentMode` integer	Payment Mode Type ID
`transactionId` integer	Transaction ID
`paymentProof` string optional	Proof of payment image (jpeg/png)
`paymentType` integer	Payment Type ID
`invoiceId` integer	Invoice ID (provide only if `paymentType` is Against Invoice)

Response Properties

`success` boolean	Indicates payments successfully added: `true`
`data` string	Success message

JSON
TypeScript

Request Sample
{
    "owId": 123654,
    "paymentAmount": 5000,
    "paymentDate": "2025-12-01",
    "paymentMode": 1,
    "transactionId": 10,
    "paymentProof": "image.png",
    "paymentType": 2,
    "invoiceId": 34
}

Response 200
{
    "success": true,
    "data": "Payment added 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 AddPaymentforcustomer(): Promise<Responses> {
  const options = {
    method: 'POST',
    url: 'https://app.iqm.com/api/v3/fa/customer/payment/add',
    requestBody?: {
      content: {
        "application/x-www-form-urlencoded": {
          owId: `number`,
          paymentAmount: `number`,
          paymentDate: `string`,
          paymentMode: `number`,
          transactionId: `string`,
          paymentProof: `string`,
          paymentType: `number`,
          invoiceId: `number`,
        }
      }
    }
  };

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

About IQM Customers​

More Resources​

Before You Begin​

Log In​

Authentication​