Interview API Developer Guide


By using this API, this API documentation, and/or building the integration, you agree to the Additional API Terms and Guidelines.


Use the Interview API to schedule and conduct virtual interviews with job candidates. This guide explains how to create, update, get, and find virtual interview events.

Before you start

Use of this API is gated by a developer agreement. Contact marketplacesupport@indeed.com to request access before attempting to develop against this API.

Read the additional terms and guidelines to understand Indeed’s requirements to use the Interview API.

Guidelines:

  • You agree to place a button in your user interface that will allow your clients (Employers) to create an interview with Indeed Platform. The button will meet the specifications provided by Indeed.
  • You agree to accurately describe to a Jobseeker:
    • What information and data you collect from and about that Jobseeker and how that data is shared with Indeed when such Jobseekers are scheduled for an interview, including how you handle and share such information and data.
  • You also agree to honor a Jobseeker request for their information and data that you collect in connection with any API.
  • You agree to provide ATS Name and Interviewee email address via this API.
  • You also agree to provide the Employer Name when that data is available to you.

Follow these steps to get a client ID for your application and authenticate using an OAuth token generated by an Indeed account.

  • Request the interviews.schedule, employer_access, and offline_access scopes when requesting the authorization code.
  • Allow a user to select an Indeed employer if one is associated with the user's Indeed account. This will be returned to the caller as an advertiser ID in an ID token; it represents that employer.
  • You will receive an access token (lasts 1h), a refresh token (lasts 60d), and an ID token (contains user information).

All requests should be directed to:

POST https://apis.indeed.com/graphql
Note: The POST method must be used for all queries and mutations. The GET method is not supported.

The query, variable inputs, and an optional operation name should be included in the POST body:

{
  "query" : "..." ,
  "operationName" : "..." ,
  "variables" : { "myVariable" : "someValue" , ... }
}

Mutations

Create a new event

To create an interview:

  1. Call our API and provide a list of email addresses of known interviewers.

  2. Provide information about the interviewee. The interviewee field itself is optional but if provided, both the name and email fields are required.

    • name: Provide a string for the interviewee name.

    • email: Provide a valid email string.

  3. Provide a startTime and endTime for the interview formatted as a RFC3339 string value with timezone offset.

  4. Provide a string for the title of the interview (likely the same as the calendar event).

  5. Provide a timezone for the interview in the IANA Time Zone Database format. This will be used to display time for both the interviewee and interviewers in the event. The timezone value is separate from the startTime and endTime offset.

  6. Provide strings for:

    • atsName: The partner application (usually ATS) that the request is from. This is a required field.

    • employerName: The employer name (if you have it).


Note:
  • The API does not require an interviewee object to be sent during interview creation. However, if one is not provided, the API will not return the interviewee URL.
  • If you don’t have the name of an interviewee at time of creation, we recommend you omit this field. Once you have that information, you can add it to the interview event using the Update mutation.
  • If you don’t have an interviewee name but need an interviewee URL, we recommend you create an interviewee object with the name Candidate. You can always change the interviewee object later by updating the interview event.

Example request to Create an event

mutation CreateEvent {
  createVirtualInterviewEvent(input:{
    startTime: "2022-08-18T22:30:00+00:00"
    endTime: "2022-08-18T23:30:00+00:00"
    title: "Interview with Candidate"
    timezone: "America/Los_Angeles"
    interviewers: [{email: "interviewer1@indeed.com"}, {email: "interviewer2@indeed.com"}]
    interviewee: {name: "Candidate", email: "candidate@example.com"}
    requestMetadata: {atsName: "ExampleATS", employerName: "Test Company"}
    languageCode: "fr"
    countryCode: "CA"
  }) {
    virtualInterviewEvent {
      id
      countryCode
      languageCode
      interviewerLobbyUrl
      intervieweesConnection {
        interviewees {
          intervieweeLobbyUrl
          name
          email
        }
      }
      interviewersConnection {
        pageInfo {
          endCursor
        }
        interviewers {
          email
        }
      }
    }
  }
}
Note: You must get the URL for the interviewee from the intervieweeConnection.interviewee list.

The Interview API returns the following after the call is made:

  • Confirmation that the interview was scheduled or an error status.
  • A unique interview ID that can then be used to read, update, and cancel an interview.

Indeed emails each interviewer included in the event immediately to let them know they’ve been added to the interview. A few minutes before the interview begins, Indeed emails the interviewee to remind them that they have an interview coming up and to provide the link again.

The interview scheduler notifies all attendees that the event has been created, adds calendar items on the calendar of each interviewer, sends the interviewer link to the interviewers, and sends the interviewee link to the interviewee.

When it’s time to start the interview, interviewers must log in with Indeed accounts matching the email address that was scheduled. Any interviewer without an Indeed account will need to create one. Interviewees do not need to create accounts.

Update an existing event

  • Authenticate using an OAuth token with an account that represents one of the interviewers on the event, or the scheduler.

  • Call our API using the updateVirtualInterviewEvent mutation to update the interview. Only one update type is allowed per mutation.

Available update types include:

Reschedule an event

  • Provide the unique interview ID.

  • Provide the new startTime and endTime formatted as RFC3339 string values with timezone offsets.

Example request to Reschedule an interview

mutation RescheduleEvent {
  updateVirtualInterviewEvent(input: {
    reschedule: {
      id: "aXJpOi8vYXBpcy5pbmRlZWQuY29tL1ZpcnR1YWxJbnRlcnZpZXdFdmVudC84OTg2NzFjLWE1NmItNDBhNC05MDNmLWE3YmE5NTUxNTExOQ=="
      startTime: "2022-08-19T22:30:00+00:00"
      endTime: "2022-08-19T23:30:00+00:00"
    }
  }) {
    event {
      id
      status
      title
      startTime
      endTime
      timezone
      languageCode
      countryCode
      interviewerLobbyUrl
      interviewersConnection {
        interviewers {
          name
          email
        }
      }
      intervieweesConnection {
        interviewees {
            intervieweeLobbyUrl
            name
            email
        }
      }
    }
  }
}

Add interviewers to an event

  • Provide the unique interview ID.

  • Provide the list of interviewers to be added formatted as emails in string form.

Example request to Add an Interviewer to an event

mutation AddInterviewersToEvent{
  updateVirtualInterviewEvent(input:{
    addInterviewers:{
      id: "aXJpOi8vYXBpcy5pbmRlZWQuY29tL1ZpcnR1YWxJbnRlcnZpZXdFdmVudC84OTg2NzFjLWE1NmItNDBhNC05MDNmLWE3YmE5NTUxNTExOQ=="
      interviewers: [
        {
          email: "test4@email.com"
        },
        {
          email: "test2@email.com"
        },
        {
          email: "test3@email.com"
        }
      ]
    }
  }) {
    event {
      id
      status
      title
      startTime
      endTime
      timezone
      languageCode
      countryCode
      interviewerLobbyUrl
      interviewersConnection {
        interviewers {
          name
          email
        }
      }
      intervieweesConnection {
        interviewees {
            intervieweeLobbyUrl
            name
            email
        }
      }
    }
  }
}

Add an interviewee to an event

  • Provide the unique interview ID for the event that will include the interviewee.

  • Provide information about the interviewee to be added

    • name: Provide a string for the interviewee name. Name is a required field.

    • email: Provide a valid email string. Email is a required field.

Note:
  • There can only ever be one interviewee associated with an interview, and it can't be changed once one it is added.
  • If the interviewee of an event is incorrect or must be changed, please cancel the event and create a new one with the correct information.

Example request to Add an Interviewee to an event

mutation AddIntervieweeToEvent{
  updateVirtualInterviewEvent(input:{
    addInterviewee:{
      id: "aXJpOi8vYXBpcy5pbmRlZWQuY29tL1ZpcnR1YWxJbnRlcnZpZXdFdmVudC84OTg2NzFjLWE1NmItNDBhNC05MDNmLWE3YmE5NTUxNTExOQ=="
      interviewee: [
        {
          name: "intervieweeName"
          email: "test4@email.com"
        }
      ]
    }
  }) {
    event {
      id
      status
      title
      startTime
      endTime
      timezone
      languageCode
      countryCode
      interviewerLobbyUrl
      interviewersConnection {
        interviewers {
          name
          email
        }
      }
      intervieweesConnection {
        interviewees {
            intervieweeLobbyUrl
            name
            email
        }
      }
    }
  }
}

Set the title of an event

  • Provide the unique interview ID.

  • Provide the new title in string form.

Example request to Update the Title of an event

mutation SetTitleOfEvent{
  updateVirtualInterviewEvent(input:{
    setTitle:{
      id: "aXJpOi8vYXBpcy5pbmRlZWQuY29tL1ZpcnR1YWxJbnRlcnZpZXdFdmVudC84OTg2NzFjLWE1NmItNDBhNC05MDNmLWE3YmE5NTUxNTExOQ=="
      title: "Interview with Candidate"
    }
  }) {
    event {
      id
      status
      title
      startTime
      endTime
      timezone
      languageCode
      countryCode
      interviewerLobbyUrl
      interviewersConnection {
        interviewers {
          name
          email
        }
      }
      intervieweesConnection {
        interviewees {
            intervieweeLobbyUrl
            name
            email
        }
      }
    }
  }
}

Cancel an existing event

To cancel an interview:

  • Authenticate using an OAuth token with an account that represents one of the interviewers on the event, or the scheduler.

  • Call our API to cancel the interview.

  • Provide the unique interview ID.

Example request to Cancel an event

mutation CancelEvent {
  cancelVirtualInterviewEvent(input: {
     id: "aXJpOi8vYXBpcy5pbmRlZWQuY29tL1ZpcnR1YWxJbnRlcnZpZXdFdmVudC84OTg2NzFjLWE1NmItNDBhNC05MDNmLWE3YmE5NTUxNTExOQ=="
  }) {
    virtualInterviewEvent {
      id
      status
      title
      startTime
      endTime
      timezone
      languageCode
      countryCode
      interviewerLobbyUrl
      interviewersConnection {
        interviewers {
          name
          email
        }
      }
      intervieweesConnection {
        interviewees {
            intervieweeLobbyUrl
            name
            email
        }
      }
    }
  }
}

Queries

Get details about specific interviews

To access an interview or multiple interviews:

  • Authenticate using an OAuth token with an account that represents one of the interviewers on the event, or the scheduler.

  • Call our API to query for the interview.

  • Provide the unique interview ID or a list of interview IDs.

Example request to retrieve details about two interviews

query GetEvent {
  virtualInterviewEvents(input: {
    ids: [
      "aXJpOi8vYXBpcy5pbmRlZWQuY29tL1ZpcnR1YWxJbnRlcnZpZXdFdmVudC9jMGNiZmNmMy05NjFhLTRiNmYtYTE5OS1lNDA0M2Y0MDE2Y2Y=",
      "aXJpOi8vYXBpcy5pbmRlZWQuY29tL1ZpcnR1YWxJbnRlcnZpZXdFdmVudC8zZjM3MmEzNy05NTI5LTQ0NmItYmQ5OC01ZGJjOGMwNTdjODQ="
    ]
  }) {
    interviewEvents {
      id
      interviewerLobbyUrl
      intervieweesConnection {
        interviewees {
          intervieweeLobbyUrl
          name
          email
        }
      }
      interviewersConnection {
        pageInfo {
          endCursor
        }
        interviewers {
          email
        }
      }
    }
  }
}

Find all interviews within a date range

To find interviews based on filter criteria:

  • Authenticate using an OAuth token with an account that represents one of the interviewers on the event, or the scheduler.

  • Call our API to access the interview:

    • By default, the first 10 items will be returned from the query per page. Include the first field with the number of events to return per page. The maximum number of events that can be returned per page is 100.

    • after: The pagination cursor from which to start from. This field can be omitted if requesting the first page of events. Include the endCursor or startCursor from a previous findVirtualInterviewEvents request to get the next or previous page.

    • input: Additional fields on which to filter. Query for events before or after a specified startTime or endTime.

Example Find request

The following is a paginated request to find interviews after a certain date:

query FindEvents {
  findVirtualInterviewEvents(
    first: 50,
    after: "ZmIyNDUxZjAtYjBjMy00NTljLTk4MGItNTVlMThhNWNlOWU0fDQ"
    input: {
      startTime: {after: "2022-06-29T22:00:00+00:00"}
    }
  ) {
    events {
      id
      title
      startTime
      endTime
      interviewersConnection {
        interviewers {
          email
        }
      }
    }
    pageInfo {
      startCursor
      endCursor
      hasNextPage
      hasPreviousPage
    }
    totalCount
  }
}

Troubleshooting common errors

When a request fails, the data field will be null, and the errors field will contain information about what went wrong.

Example invalid request

Request

In this request, the pagination cursor ("after") is invalid (too short, contains special characters).

query {
  findVirtualInterviewEvents(
  input: {
    startTime: {
      after: "2022-07-19T23:21:27+00:00"
      before: "2022-07-19T23:21:30+00:00"
    }
    endTime: {
      after: "2022-07-19T23:21:27+00:00"
      before: "2022-07-19T23:21:30+00:00"
    }
    }, after: "1˙∆") {
      events {
      id
    }
  }
}

Corresponding response

In an error response, "data" will be null. Information about what went wrong will be in the "errors" section, with details in "message".

{
  "errors": [
    {
      "message": "Encountered issue parsing cursor '1˙∆'.",
      "locations": [
      {
        "line": 3,
        "column": 3
      }
      ],
      "path": [
        "findVirtualInterviewEvents"
      ],
      "extensions": {
        "code": "BAD_USER_INPUT",
        "logLevel": "INFO"
      }
    }
  ],
  "data": {
    "findVirtualInterviewEvents": null
  }
}
Note: When using the Get query type, if some IDs encountered errors, those will be displayed as null in "data" alongside any successes.

Common error types

The table below explains the most commonly seen error types.

Error Type Meaning and Common Causes
BAD_USER_INPUT

The value of an input parameter is invalid or the server is unable to process your request based on the provided input. Please consult the provided error message for details.

INTERNAL_SERVER_ERROR

The server encountered an unexpected failure, error, or exception and did not provide a response. This can happen for various reasons and is closely monitored by Indeed. Please try your request again.

UNAUTHENTICATED The request was not attempted because it did not include sufficient authentication credentials. Please refer to the authorization guide for details on how to provide authentication credentials.
FORBIDDEN

Valid authentication credentials are present but insufficient to perform the associated query or mutation. Please consult the provided error message for details. This is what you will see when attempting to access an interview that does not exist.

Valid authentication credentials are present but insufficient to perform the associated query or mutation. Please consult the provided error message for details. Note - this is what you will see when attempting to access an event that does not exist.

Troubleshooting authorization errors

Authorization endpoints (such as https://apis.indeed.com/oauth/v2/tokens) return errors in the format required by the OAuth 2.0 specification. For example:

{
    "error_description": "Invalid grant",
    "error": "invalid_grant"
}
Error Code Meaning and Common Causes
invalid_grant

There was a problem with your client credentials (client ID and client secret), authorization code or refresh token.

This error is often caused by an incorrect client ID or client secret. Please check that:

  • You didn't happen to leave out or include extra characters at the beginning or the end of either credential when copying them from the Manage app credentials page.
  • If you recently rotated your client credentials (created a new client secret and deleted the old secret associated with the client ID), verify that you have updated all your credential stores with the new client secret.

If you are using Client Credentials Flow (2-legged OAuth), another common cause is that client credentials grant type isn't enabled. Please verify that Allowed grant types include Client credentials on the Manage app credentials page.

If you are using Authorization Code Flow (3-legged OAuth), common causes include:

  • Authorization code grant type wasn't enabled. Please verify that Allowed grant types include Authorization code on the Manage app credentials page.
  • The redirect_uri parameter passed to https://apis.indeed.com/oauth/v2/tokens didn't match the redirect_uri passed to https://secure.indeed.com/oauth/v2/authorize.
  • The authorization code has expired or has already been used. Each authorization code can only be used once. To renew access tokens without reauthorization, you must request the offline_access scope and store the refresh token you receive along with the first access token.
  • The refresh token is no longer valid. You must ask the user to complete the authorization flow again to receive another refresh token. The refresh token could have become invalid because:
    • The user revoked the authorization they previously gave to your app.
    • Your app has repeatedly requested authorization from the same user and the oldest refresh tokens for this user have been invalidated. Requesting authorization more than once is perfectly fine, but be sure to update the refresh token stored by your app after each successful authorization.
    • The refresh token has expired because it hasn't been used recently. Refresh tokens expire 60 days after the last usage, or 60 days after issue if never used.
  • The authorization code or refresh token is valid but was issued to a different app. Be sure to use the same client ID (and a corresponding client secret) in all stages of the authorization process.

The error_description field will only contain a generic "Invalid grant" message. To resolve this error, carefully check all the potential causes listed above that apply to your situation.

invalid_request

There was a problem with request parameters:

  • A required parameter was missing, or a parameter had an invalid value.
  • The request to https://apis.indeed.com/oauth/v2/tokens included query string parameters in the request URL. Be sure to send all parameters in the HTTP request body using the application/x-www-form-urlencoded format.
  • The app's account (2-legged OAuth) or the user (3-legged OAuth) doesn't have the permission to access the employer specified with the employer parameter.
  • The value of the employer parameter wasn't a valid employer ID. The employer IDs accepted by the employer parameter are different from the values accepted by the legacy advertiserId parameter. You can get the list of valid values by calling the AppInfo (2-legged OAuth) or UserInfo (3-legged OAuth) authorization endpoint, or if you have a master account, calling the GET /v1/subaccounts endpoint of the Sponsored Jobs API.

The message in the error_description field may help to identify the missing or invalid parameter or other problem.

unsupported_grant_type The requested grant_type was neither client_credentials (2-legged OAuth) nor authorization_code or refresh_token (3-legged OAuth). Be sure to use one of the supported grant types.

Back to top

GraphQL schema

type Mutation {
    """
   Create a Virtual Interview Event with one interviewee.
   This adds the account user scheduling the event to the interviewer list for the event.
   A developer must get the URL for the interviewee from the intervieweeConnection list.
    """
    createVirtualInterviewEvent(
        input: CreateVirtualInterviewEventInput!
    ): CreateVirtualInterviewEventPayload

    """
    Cancel a VirtualInterviewEvent
    """
    cancelVirtualInterviewEvent(
        input: CancelVirtualInterviewEventInput!
    ): CancelVirtualInterviewEventPayload

    """
    Update the details of a VirtualInterviewEvent
    """
    updateVirtualInterviewEvent(
        input: UpdateVirtualInterviewEventInput!
    ): UpdateVirtualInterviewEventPayload
}

type Query {
    """
    Returns Virtual Interview Events from a list of IDs
    """
    virtualInterviewEvents(
        input: VirtualInterviewEventsInput!
    ): VirtualInterviewEventsPayload

    """
    Returns a list of interview events with an optional filter
    """
    findVirtualInterviewEvents(
        first: Int = 10,
        after: String,
        input: FindVirtualInterviewEventsInput!
    ): VirtualInterviewEventsConnection
}

"""
Input for the Virtual Interview Event.
VirtualInterviewIntervieweeInput is not required.
Hold on to the VirtualInterviewInterviewee ID to make updates to the VirtualInterviewInterviewee.
"""
input CreateVirtualInterviewEventInput {
    """
    The list of interviewers allowed in the VirtualInterviewEvent
    """
    interviewers: [VirtualInterviewInterviewerInput!]!
    """
    Scheduled start time for the event. RFC3339 string value with timezone offset (separate from timezone field)
    """
    startTime: DateTime!
    """
    Scheduled end time for the event. RFC3339 string value with timezone offset (separate from timezone field)
    """
    endTime: DateTime!
    """
    Timezone of the event used to display time on event pages. Timezone input should follow IANA Time Zone Database name format
    """
    timezone: TimeZone!
    """
    The title of the event specified by the scheduler
    """
    title: String!
    """
    Optional interviewee information
    """
    interviewee: VirtualInterviewIntervieweeInput
    """
    Information about the request
    """
    requestMetadata: VirtualInterviewRequestMetadataInput!
    """
    Optional country code for the event. An ISO 3166-1 - alpha 2 country code string
    """
    countryCode: CountryCode
    """
    Optional country code for the event. An ISO 3166-1 - alpha 2 country code string
    """
    countryCode: CountryCode
}

"""
Partner metadata related to the request
"""
input VirtualInterviewRequestMetadataInput {
    atsName: String!
    employerName: String
}

"""
Input for a VirtualInterviewInterviewee
"""
input VirtualInterviewIntervieweeInput {
    """
    Display name for Interviewee
    """
    name: String!
    email: EmailAddress!
}

"""
Input for a VirtualInterviewInterviewer
"""
input VirtualInterviewInterviewerInput {
    email: EmailAddress!
}

"""
Return values for createVirtualInterviewEvent mutation
"""
type CreateVirtualInterviewEventPayload {
    """
    The created Interview Event
    """
    event: VirtualInterviewEvent!
}

"""
Input for cancelling a VirtualInterviewEvent
"""
input CancelVirtualInterviewEventInput {
    """
    ID of the VirtualInterviewEvent
    """
    id: ID!
}

"""
Return value for cancelVirtualInterviewEvent mutation
"""
type CancelVirtualInterviewEventPayload {
    """
    The cancelled interview event
    """
    event: VirtualInterviewEvent!
}

"""
Only one of the following fields can be sent in one update request. The behavior depends on which field you choose.
"""
input UpdateVirtualInterviewEventInput {
    """
    Choose this field to reschedule a VirtualInterviewEvent
    """
    reschedule: RescheduleVirtualInterviewEventInput
    """
    Choose this field to add interviewers to a VirtualInterviewEvent
    """
    addInterviewers: UpdateVirtualInterviewEventInterviewersInput
    """
    Choose this field to set the title of a VirtualInterviewEvent
    """
    setTitle: UpdateVirtualInterviewEventTitleInput
}

"""
Child of UpdateVirtualInterviewEventInput used for rescheduling events.
"""
input RescheduleVirtualInterviewEventInput {
    """
    ID of the VirtualInterviewEvent
    """
    id: ID!
    """
    Updated scheduled start time for the event. RFC3339 string value with timezone offset
    """
    startTime: DateTime!
    """
    Updated scheduled end time for the event. RFC3339 string value with timezone offset
    """
    endTime: DateTime!
}

"""
Child of UpdateVirtualInterviewEventInput used for updating interviewers. Currently implemented functionality:
-Adding interviewers to an event (not atomic)
"""
input UpdateVirtualInterviewEventInterviewersInput {
    """
    ID of the VirtualInterviewEvent
    """
    id: ID!
    """
    The list of interviewers to use to perform the update.
    """
    interviewers: [VirtualInterviewInterviewerInput!]!
}

"""
Child of UpdateVirtualInterviewEventInput used for setting the title of events.
"""
input UpdateVirtualInterviewEventTitleInput {
    """
    ID of the VirtualInterviewEvent
    """
    id: ID!
    """
    Updated title of the event
    """
    title: String!
}

"""
Return value for updateVirtualInterviewEvent mutation
"""
type UpdateVirtualInterviewEventPayload {
    """
    The updated interview event
    """
    event: VirtualInterviewEvent!
}

"""
Input object for virtualInterviewEvents query
"""
input VirtualInterviewEventsInput {
    """
    The unique identifiers for the events to return
    """
    ids: [ID!]!
}

"""
Return values for virtualInterviewEvents query. Note: Null are values returned when input ids are not found
"""
type VirtualInterviewEventsPayload {
    """
    List of returned Interview Events
    """
    events: [VirtualInterviewEvent]!
}

"""
Time range information for use in date filtering
"""
input VirtualInterviewEventDateTimeRangeFilterInput {
    after: DateTime
    before: DateTime
}

"""
Input object for findVirtualInterviewEvents
"""
input FindVirtualInterviewEventsInput {
    """
    Range filter around the event's start time
    """
    startTime: VirtualInterviewEventDateTimeRangeFilterInput
    """
    Range filter around the event's end time
    """
    endTime: VirtualInterviewEventDateTimeRangeFilterInput
    """
    An ordered array of sort options, where a lower index takes higher priority.
    """
    sort: [VirtualInterviewEventSortOptionInput!]
}

"""
An input that defines which field is to be sorted and in which direction
"""
input VirtualInterviewEventSortOptionInput {
    """
    The field to sort on
    """
    field: VirtualInterviewEventSortField!
    """
    The direction it should be sorted
    """
    order: SortDirection! = ASC
}

"""
The virtual interview event fields that can be sorted on
"""
enum VirtualInterviewEventSortField {
    START_TIME
    END_TIME
}

"""
Sort direction
"""
enum SortDirection {
    ASC
    DESC
}

"""
Response object for VirtualInterviewEvent(s) that contains pagination information
"""
type VirtualInterviewEventsConnection {
    """
    Edges for pagination
    """
    edges: [VirtualInterviewEventEdge!]!
    """
    Page info for pagination. Defined in com.indeed.graphql.relay.PageInfo
    """
    pageInfo: PageInfo!
    """
    The interview events for this page
    """
    events: [VirtualInterviewEvent!]!
    """
    The total number of events matching filter criteria (ignoring pagination).
    """
    totalCount: Int!
}

"""
Edge information for VirtualInterviewEvent pagination
"""
type VirtualInterviewEventEdge {
    """
    The interview event item
    """
    node: VirtualInterviewEvent!
    """
    The cursor position of the node
    """
    cursor: String!
}

type VirtualInterviewEvent {
    """
    The event's unique identifier
    """
    id: ID!
    """
    The title of the event specified by the scheduler
    """
    title: String!
    """
    Scheduled start time for the event. RFC3339 string value with timezone offset (separate from timezone field)
    """
    startTime: DateTime!
    """
    Scheduled end time for the event. RFC3339 string value with timezone offset (separate from timezone field)
    """
    endTime: DateTime!
    """
    Timezone of event used to display time on event pages. Timezone input should follow IANA Time Zone Database name format
    """
    timezone: TimeZone!
    """
    List of interviewers allowed in the Virtual Interview Event
    """
    interviewersConnection(first: Int = 10, after: String, before: String, last: Int) : VirtualInterviewInterviewersConnection!
    """
    Interviewer’s URL to the event lobby for this VirtualInterviewEvent
    """
    interviewerLobbyUrl: WebUrl!
    """
    Landing page that directs the interviewee and interviewers to enter the lobby. This field is only available to OAuth clients.
    """
    interviewLandingPageUrl: WebUrl
    """
    The country code of the event. An ISO 3166-1 - alpha 2 country code string
    """
    countryCode: CountryCode
    """
    The list of interviewees for a Virtual Interview Event
    """
    intervieweesConnection(first: Int = 10, after: String, before: String, last: Int) : VirtualInterviewIntervieweesConnection!
    """
    The current status of the VirtualInterviewEvent
    """
    status: VirtualInterviewEventStatus!
}

type VirtualInterviewInterviewersConnection {
    """
    Edges for pagination
    """
    edges: [VirtualInterviewInterviewerEdge!]!
    """
    Page info for pagination. Defined in com.indeed.graphql.relay.PageInfo
    """
    pageInfo: PageInfo!
    """
    The list of allowed interviewers for this page
    """
    interviewers: [VirtualInterviewInterviewer!]!
    """
    The total result count ignoring pagination
    """
    totalCount: Int!
}

type VirtualInterviewIntervieweesConnection {
    """
    Edges for pagination
    """
    edges: [VirtualInterviewIntervieweeEdge!]!
    """
    Page info for pagination. Defined in com.indeed.graphql.relay.PageInfo
    """
    pageInfo: PageInfo!
    """
    The list of interviewees for this page
    """
    interviewees: [VirtualInterviewInterviewee!]!
    """
    The total result count ignoring pagination
    """
    totalCount: Int!
    """
    The list of jobs for this event
    """
    jobsSummary: [VirtualInterviewJob]!
}

type VirtualInterviewInterviewee {
    """
    The unique identifier of the interviewee for the VirtualInterviewEvent
    """
    id: ID!
    """
    The interviewee's name
    """
    name: String!
    """
    The interviewee's email address
    """
    email: EmailAddress
    """
    The URL for the interviewee to join the lobby for the VirtualInterviewEvent
    """
    intervieweeLobbyUrl: WebUrl!
    """
    Information about the job the interviewee is interviewing for
    """
    job: VirtualInterviewJob
}

"""
Union type describing the output options for job information
"""
union VirtualInterviewJob = VirtualInterviewJobInfo | EmployerJob


type VirtualInterviewJobInfo {
    """
    The job title
    """
    title: String
    """
    The job location
    """
    location: String
}

type VirtualInterviewInterviewer {
    """
    The interviewer's global unique identifier
    """
    id: ID!
    """
    The interviewee's email address
    """
    email: EmailAddress!
    """
    The interviewee's name
    """
    name: String
}

"""
Current status of the Event
"""
enum VirtualInterviewEventStatus {
    SCHEDULED
    STARTED
    ENDED
    ARCHIVED
    CANCELLED
}

type VirtualInterviewInterviewerEdge {
    """
    The interviewer item
    """
    node: VirtualInterviewInterviewer!
    """
    The cursor position of the node
    """
    cursor: String!
}

type VirtualInterviewIntervieweeEdge {
    """
    The interviewee item
    """
    node: VirtualInterviewInterviewee!
    """
    The cursor position of the node
    """
    cursor: String!
}

"""
Information about pagination in a connection
"""
type PageInfo {
    """
    When paginating forwards, the cursor to continue. Null if there is no next page
    """
    endCursor: String
    """
    Indicates if there are more pages to fetch
    """
    hasNextPage: Boolean!
    """
    Indicates if there are any pages prior to the current page
    """
    hasPreviousPage: Boolean!
    """
    When paginating backwards, the cursor to continue. Null if there is no previous page
    """
    startCursor: String
}


Back to top