---
updatedAt: 2026-10-05T19:24:05.000Z
agentTools:
  projectIndex: https://integrate.apploi.com/llms.txt
---

# /easy-apply

This endpoint submits a job application to Apploi. It serves both API apply flows:

* **Quick Apply**, for jobs whose `apply_method` in the [/jobs/search](https://integrate.apploi.com/reference/get_jobs-search) response is `easy_apply_endpoint`. The job has no screening questions.
* **Full Apply**, for jobs whose `apply_method` is `full_apply_endpoint`. The application also carries the applicant's answers to the job's questions.

Jobs whose `apply_method` is `redirect` can't be applied to through the API.

## Examples

The examples read your API key from an environment variable named `APPLOI_API_KEY`. Before running them, set `APPLOI_API_KEY` in your own environment to the Partner API key you received from Apploi. The examples do not set it for you, and the key should never be written into your code.

### Quick Apply

A Quick Apply request needs three things:

* the applicant's `email` and `fullName`,
* the job's id, as a **string**, in `job.jobId`,
* the job's `partner_attributes` from the `/jobs/search` response, sent back unchanged.

`phoneNumber` is optional. Leave out `get_person_token`, because the bearer token it returns belongs to the deprecated bearer-token flow. To attach a resume, add `applicant.resume.file`, as described in the body schema on this page.

The examples define a `submit_application` function (`submitApplication` in TypeScript), which the later examples reuse. It sorts each response into the outcomes described under [What the response means](#what-the-response-means).

```bash cURL
# APPLOI_API_KEY must hold the Partner API key you received from Apploi.
# These examples do not set it for you: set it yourself, in your own
# environment, before running them. For example, in your shell:
#   export APPLOI_API_KEY="<the API key you received from Apploi>"

curl -sS -X POST https://partners.apploi.com/easy-apply \
  -H "X-Api-Key: $APPLOI_API_KEY" \
  -H "Content-Type: application/json" \
  -w "\nHTTP status: %{http_code}\n" \
  -d '{
    "applicant": {
      "email": "jane.doe@example.com",
      "fullName": "Jane Doe",
      "phoneNumber": "555-010-0123"
    },
    "job": {
      "jobId": "468036"
    },
    "partner_attributes": {
      "sponsored": true,
      "search_fetch_id": "394f44dc0aff4ee6ae469221e8934ee8",
      "page": 1,
      "order": 2
    }
  }'
```
```python Python
import os

import requests

# APPLOI_API_KEY must hold the Partner API key you received from Apploi.
# These examples do not set it for you: set it yourself, in your own
# environment, before running them. For example, in your shell:
#   export APPLOI_API_KEY="<the API key you received from Apploi>"
API_KEY = os.environ["APPLOI_API_KEY"]

def submit_application(body):
    response = requests.post(
        "https://partners.apploi.com/easy-apply",
        headers={"X-Api-Key": API_KEY},
        json=body,
        timeout=60,
    )
    if response.status_code == 200:
        return "submitted", response.json()
    if response.status_code == 409:
        # The applicant has already applied to this job. Don't retry.
        return "already_applied", response.json()
    if response.status_code == 412:
        # Only sent when "enqueue" is False. Don't retry.
        result = response.json()
        if "job_id" in (result.get("errors") or {}):
            # The job is closed or doesn't exist.
            return "job_closed", result
        # The application already exists, for example from an earlier attempt.
        return "already_applied", result
    # 400: fix the request before sending it again. 5xx: retry with backoff.
    raise RuntimeError(f"Request failed with status {response.status_code}: {response.text}")

outcome, result = submit_application({
    "applicant": {
        "email": "jane.doe@example.com",
        "fullName": "Jane Doe",
        "phoneNumber": "555-010-0123",
    },
    "job": {"jobId": "468036"},  # a string, not a number
    # Copied unchanged from the job's /jobs/search result
    "partner_attributes": {
        "sponsored": True,
        "search_fetch_id": "394f44dc0aff4ee6ae469221e8934ee8",
        "page": 1,
        "order": 2,
    },
})
print(outcome, result)
```
```typescript TypeScript
// APPLOI_API_KEY must hold the Partner API key you received from Apploi.
// These examples do not set it for you: set it yourself, in your own
// environment, before running them. For example, in your shell:
//   export APPLOI_API_KEY="<the API key you received from Apploi>"
if (!process.env.APPLOI_API_KEY) {
  throw new Error("Set APPLOI_API_KEY to the Partner API key you received from Apploi");
}
const API_KEY: string = process.env.APPLOI_API_KEY;

type Outcome = "submitted" | "already_applied" | "job_closed";

async function submitApplication(body: object): Promise<{ outcome: Outcome; result: any }> {
  const response = await fetch("https://partners.apploi.com/easy-apply", {
    method: "POST",
    headers: { "X-Api-Key": API_KEY, "Content-Type": "application/json" },
    body: JSON.stringify(body),
  });
  if (response.status === 200) {
    return { outcome: "submitted", result: await response.json() };
  }
  if (response.status === 409) {
    // The applicant has already applied to this job. Don't retry.
    return { outcome: "already_applied", result: await response.json() };
  }
  if (response.status === 412) {
    // Only sent when "enqueue" is false. Don't retry.
    const result = await response.json();
    if (result.errors?.job_id !== undefined) {
      // The job is closed or doesn't exist.
      return { outcome: "job_closed", result };
    }
    // The application already exists, for example from an earlier attempt.
    return { outcome: "already_applied", result };
  }
  // 400: fix the request before sending it again. 5xx: retry with backoff.
  throw new Error(`Request failed with status ${response.status}: ${await response.text()}`);
}

const { outcome, result } = await submitApplication({
  applicant: {
    email: "jane.doe@example.com",
    fullName: "Jane Doe",
    phoneNumber: "555-010-0123",
  },
  job: { jobId: "468036" }, // a string, not a number
  // Copied unchanged from the job's /jobs/search result
  partner_attributes: {
    sponsored: true,
    search_fetch_id: "394f44dc0aff4ee6ae469221e8934ee8",
    page: 1,
    order: 2,
  },
});
console.log(outcome, result);
```
```ruby Ruby
require "json"
require "net/http"
require "uri"

# APPLOI_API_KEY must hold the Partner API key you received from Apploi.
# These examples do not set it for you: set it yourself, in your own
# environment, before running them. For example, in your shell:
#   export APPLOI_API_KEY="<the API key you received from Apploi>"
API_KEY = ENV.fetch("APPLOI_API_KEY")

def submit_application(body)
  uri = URI("https://partners.apploi.com/easy-apply")
  request = Net::HTTP::Post.new(uri)
  request["X-Api-Key"] = API_KEY
  request["Content-Type"] = "application/json"
  request.body = JSON.generate(body)

  response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: 60) do |http|
    http.request(request)
  end

  case response.code
  when "200" then [:submitted, JSON.parse(response.body)]
  # The applicant has already applied to this job. Don't retry.
  when "409" then [:already_applied, JSON.parse(response.body)]
  # Only sent when "enqueue" is false. Don't retry.
  when "412"
    result = JSON.parse(response.body)
    # With errors.job_id, the job is closed or doesn't exist. Otherwise the
    # application already exists, for example from an earlier attempt.
    (result["errors"] || {}).key?("job_id") ? [:job_closed, result] : [:already_applied, result]
  # 400: fix the request before sending it again. 5xx: retry with backoff.
  else raise "Request failed with status #{response.code}: #{response.body}"
  end
end

outcome, result = submit_application(
  applicant: {
    email: "jane.doe@example.com",
    fullName: "Jane Doe",
    phoneNumber: "555-010-0123"
  },
  job: { jobId: "468036" }, # a string, not a number
  # Copied unchanged from the job's /jobs/search result
  partner_attributes: {
    sponsored: true,
    search_fetch_id: "394f44dc0aff4ee6ae469221e8934ee8",
    page: 1,
    order: 2
  }
)
puts outcome, result
```

### What the response means

Decide what happened from the status code, not from the body. A successful response also contains a `developer_message`.

| Status | Meaning                                                                                                                                                                                                                | What to do                                                                                                                                                                                                                                                                                                                                                |
| ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `200`  | The request was accepted.                                                                                                                                                                                              | Nothing. A `200` doesn't always mean an application was created. See [Choosing when the application is processed](#choosing-when-the-application-is-processed) for how this works by default. A `developer_message` of `Application skipped due to inactive candidate.` means the applicant's Apploi account is inactive, and no application was created. |
| `409`  | The applicant has already applied to this job. Applications are matched on email address.                                                                                                                              | Treat it as "already applied", not as a failure. Don't retry.                                                                                                                                                                                                                                                                                             |
| `412`  | Only sent when `enqueue` is `false`. If `errors` has a `job_id`, the job is closed or doesn't exist. Otherwise the application already exists, usually because an earlier attempt to send it is still being processed. | With `job_id`, remove the job from your listings. Otherwise, treat it like a `409`. Don't retry in either case.                                                                                                                                                                                                                                           |
| `400`  | The request is invalid, for example a missing `email` or an answer that doesn't fit its question. `developer_message` says what's wrong.                                                                               | Fix the request before sending it again. An unchanged retry fails the same way.                                                                                                                                                                                                                                                                           |
| `5xx`  | Something failed on Apploi's side, or the request took longer than 29 seconds.                                                                                                                                         | Wait, then retry with exponential backoff.                                                                                                                                                                                                                                                                                                                |

A retry after a `5xx` is safe: Apploi doesn't create a second application for the same applicant and job. The exception is a team that has repeat applications turned on (they're off by default). The retry may return `200` or `409`, or, with `enqueue: false`, a `412` without a `job_id`.

A `200` response looks like this:

```json
{
  "developer_message": "Submit Successful",
  "errors": null,
  "info": {
    "person_id": 32424609,
    "job_id": "468036"
  }
}
```

A `409` response includes the id of the existing application:

```json
{
  "developerMessage": "This application has already been submitted.",
  "errors": {
    "application_form_id": 918273
  }
}
```

A `412` for a closed or missing job names the job. A `412` for an application that already exists has `saved_application_id` in `errors` instead.

```json
{
  "developerMessage": "Specified job doesn't exist or isn't accepting applications.",
  "errors": {
    "job_id": 468036
  }
}
```

### Choosing when the application is processed

By default, `enqueue` is `true`. Apploi checks the request, replies, and creates the application a moment later. The response is quick, but a `200` only means the request was accepted, not that the application was created. If the job has closed, or doesn't exist, you still get `200`, and the application is then dropped without notice.

Send `"enqueue": false` when you need to know straight away that the job is closed, for example to tell the applicant. Apploi then creates the application before replying, so the request takes longer, and a closed or missing job returns `412`. If part of the application, such as the resume, can't be saved, the response is still `200`, and `errors` lists what wasn't saved.

Some problems are reported straight away whichever value you send:

* a request that isn't valid returns `400`,
* a repeat application returns `409`.

These examples reuse `submit_application` (Python and Ruby) and `submitApplication` (TypeScript) from the Quick Apply example above.

```bash cURL
# APPLOI_API_KEY must hold the Partner API key you received from Apploi.
# These examples do not set it for you: set it yourself, in your own
# environment, before running them. For example, in your shell:
#   export APPLOI_API_KEY="<the API key you received from Apploi>"

curl -sS -X POST https://partners.apploi.com/easy-apply \
  -H "X-Api-Key: $APPLOI_API_KEY" \
  -H "Content-Type: application/json" \
  -w "\nHTTP status: %{http_code}\n" \
  -d '{
    "enqueue": false,
    "applicant": {
      "email": "jane.doe@example.com",
      "fullName": "Jane Doe"
    },
    "job": {
      "jobId": "468036"
    },
    "partner_attributes": {
      "sponsored": true,
      "search_fetch_id": "394f44dc0aff4ee6ae469221e8934ee8",
      "page": 1,
      "order": 2
    }
  }'
```
```python Python
outcome, result = submit_application({
    "enqueue": False,
    "applicant": {"email": "jane.doe@example.com", "fullName": "Jane Doe"},
    "job": {"jobId": "468036"},
    "partner_attributes": {
        "sponsored": True,
        "search_fetch_id": "394f44dc0aff4ee6ae469221e8934ee8",
        "page": 1,
        "order": 2,
    },
})
if outcome == "job_closed":
    print("This job is no longer accepting applications.")
```
```typescript TypeScript
const { outcome } = await submitApplication({
  enqueue: false,
  applicant: { email: "jane.doe@example.com", fullName: "Jane Doe" },
  job: { jobId: "468036" },
  partner_attributes: {
    sponsored: true,
    search_fetch_id: "394f44dc0aff4ee6ae469221e8934ee8",
    page: 1,
    order: 2,
  },
});
if (outcome === "job_closed") {
  console.log("This job is no longer accepting applications.");
}
```
```ruby Ruby
outcome, _result = submit_application(
  enqueue: false,
  applicant: { email: "jane.doe@example.com", fullName: "Jane Doe" },
  job: { jobId: "468036" },
  partner_attributes: {
    sponsored: true,
    search_fetch_id: "394f44dc0aff4ee6ae469221e8934ee8",
    page: 1,
    order: 2
  }
)
puts "This job is no longer accepting applications." if outcome == :job_closed
```

### Full Apply

A Full Apply request is a Quick Apply request with the applicant's answers added in `questions.answers`. Get the job's questions from the `questions_url` in its `/jobs/search` result. The [Full Apply guide](https://integrate.apploi.com/docs/full-apply) describes that response.

#### Formatting `questions.answers`

Each answer has the question's `id` and **exactly one** of `value` or `values`, and nothing else. Send every id and every value as a **string**, even when it is a number. The answer's form depends on the question's `type`:

| Question `type`                    | Answer                                                 | Example                                                |
| ---------------------------------- | ------------------------------------------------------ | ------------------------------------------------------ |
| `textarea`                         | `value`: any text                                      | `{"id": "1893206", "value": "Yes, license LPC-80421"}` |
| `text`, with `"format": "integer"` | `value`: a whole number from `0` to `100`, as a string | `{"id": "1877310", "value": "5"}`                      |
| `select`                           | `value`: the chosen option's `value`                   | `{"id": "1854409", "value": "1"}`                      |
| `multiselect`                      | `values`: a list of the chosen options' `value`s       | `{"id": "1841349", "values": ["0", "2"]}`              |
| `date`                             | `value`: a date in `DD/MM/YYYY` format                 | `{"id": "1920662", "value": "21/04/1990"}`             |

An option's `value` is its position in the question's `options` list, counting from `0`. For example, with these options:

```json
{
  "options": [{"value": 0, "label": "Yes"}, {"value": 1, "label": "No"}]
}
```

the answer "No" is sent as `"value": "1"`. A multiselect question takes `values` (plural); using `value` with a list returns `400`.

Each answer is checked against the job's questions. An id that isn't one of the job's questions, an option that doesn't exist, or a date in another format returns `400`, with a `developer_message` that explains the problem.

The examples below use the example questions from the Full Apply guide.

```bash cURL
# APPLOI_API_KEY must hold the Partner API key you received from Apploi.
# These examples do not set it for you: set it yourself, in your own
# environment, before running them. For example, in your shell:
#   export APPLOI_API_KEY="<the API key you received from Apploi>"

curl -sS -X POST https://partners.apploi.com/easy-apply \
  -H "X-Api-Key: $APPLOI_API_KEY" \
  -H "Content-Type: application/json" \
  -w "\nHTTP status: %{http_code}\n" \
  -d '{
    "applicant": {
      "email": "jane.doe@example.com",
      "fullName": "Jane Doe",
      "phoneNumber": "555-010-0123"
    },
    "job": {
      "jobId": "468003"
    },
    "partner_attributes": {
      "sponsored": true,
      "search_fetch_id": "394f44dc0aff4ee6ae469221e8934ee8",
      "page": 1,
      "order": 1
    },
    "questions": {
      "answers": [
        { "id": "1893206", "value": "Yes, license LPC-80421" },
        { "id": "1920662", "value": "21/04/1990" },
        { "id": "1854409", "value": "1" },
        { "id": "1841349", "values": ["0", "2"] }
      ]
    }
  }'
```
```python Python
outcome, result = submit_application({
    "applicant": {
        "email": "jane.doe@example.com",
        "fullName": "Jane Doe",
        "phoneNumber": "555-010-0123",
    },
    "job": {"jobId": "468003"},
    "partner_attributes": {
        "sponsored": True,
        "search_fetch_id": "394f44dc0aff4ee6ae469221e8934ee8",
        "page": 1,
        "order": 1,
    },
    "questions": {
        "answers": [
            {"id": "1893206", "value": "Yes, license LPC-80421"},  # textarea
            {"id": "1920662", "value": "21/04/1990"},  # date, DD/MM/YYYY
            {"id": "1854409", "value": "1"},  # select: option 1, "No"
            {"id": "1841349", "values": ["0", "2"]},  # multiselect: options 0 and 2
        ]
    },
})
print(outcome, result)
```
```typescript TypeScript
const { outcome, result } = await submitApplication({
  applicant: {
    email: "jane.doe@example.com",
    fullName: "Jane Doe",
    phoneNumber: "555-010-0123",
  },
  job: { jobId: "468003" },
  partner_attributes: {
    sponsored: true,
    search_fetch_id: "394f44dc0aff4ee6ae469221e8934ee8",
    page: 1,
    order: 1,
  },
  questions: {
    answers: [
      { id: "1893206", value: "Yes, license LPC-80421" }, // textarea
      { id: "1920662", value: "21/04/1990" }, // date, DD/MM/YYYY
      { id: "1854409", value: "1" }, // select: option 1, "No"
      { id: "1841349", values: ["0", "2"] }, // multiselect: options 0 and 2
    ],
  },
});
console.log(outcome, result);
```
```ruby Ruby
outcome, result = submit_application(
  applicant: {
    email: "jane.doe@example.com",
    fullName: "Jane Doe",
    phoneNumber: "555-010-0123"
  },
  job: { jobId: "468003" },
  partner_attributes: {
    sponsored: true,
    search_fetch_id: "394f44dc0aff4ee6ae469221e8934ee8",
    page: 1,
    order: 1
  },
  questions: {
    answers: [
      { id: "1893206", value: "Yes, license LPC-80421" }, # textarea
      { id: "1920662", value: "21/04/1990" }, # date, DD/MM/YYYY
      { id: "1854409", value: "1" }, # select: option 1, "No"
      { id: "1841349", values: ["0", "2"] } # multiselect: options 0 and 2
    ]
  }
)
puts outcome, result
```

# OpenAPI definition

````json
{
  "components": {
    "schemas": {
      "EasyApplyUTMAndResume": {
        "description": "The JSON document schema to send an application",
        "properties": {
          "applicant": {
            "description": "Contains the applicant information",
            "properties": {
              "email": {
                "default": "john.doe@example.com",
                "description": "Applicant's email",
                "type": "string"
              },
              "fullName": {
                "default": "John Doe",
                "description": "Applicant's full name (ex. John Doe)",
                "type": "string"
              },
              "phoneNumber": {
                "default": "123-456-7890",
                "description": "Applicant's phone number",
                "type": "string"
              },
              "resume": {
                "description": "Data of the applicant's resume",
                "properties": {
                  "file": {
                    "description": "Data of the uploaded resume file",
                    "properties": {
                      "contentType": {
                        "default": "application/pdf",
                        "description": "A media type (MIME type) is a standard that indicates the nature and format of the file. It is defined and standardized in IETF's RFC 6838. Resume parsing tool will use this MIME type, not the file extension, to determine how to process the file data. For example: application/pdf",
                        "type": "string"
                      },
                      "data": {
                        "default": "base64_encoded_resume_content",
                        "description": "Base64 encoded file",
                        "type": "string"
                      },
                      "fileName": {
                        "default": "resume.pdf",
                        "description": "Original file name. Filename extension must be one of: doc, docx, dot, rtf, pdf, odt, txt, htm, html",
                        "type": "string"
                      }
                    },
                    "required": [
                      "contentType",
                      "data",
                      "fileName"
                    ],
                    "type": "object"
                  }
                },
                "type": "object"
              },
              "source": {
                "default": "easy-apply",
                "description": "Application method in the source platform used by the candidate to submit this application",
                "type": "string"
              },
              "utm_campaign": {
                "default": "spring_campaign",
                "description": "Identifies a specific product promotion or strategic campaign",
                "type": "string"
              },
              "utm_medium": {
                "default": "social-media",
                "description": "Identifies what type of link was used, such as cost per click or email or social-media",
                "type": "string"
              },
              "utm_source": {
                "default": "linkedin",
                "description": "Identifies which site sent the traffic. Source of the applicant (facebook, twitter, linkedin, etc.)",
                "type": "string"
              }
            },
            "required": [
              "email",
              "fullName"
            ],
            "type": "object"
          },
          "applicant_status": {
            "default": "New",
            "description": "This field is used to set the status of the candidate's application upon creation. The value of this field is expected to be a string which corresponds to a valid application status in the Apploi platform found in the [Application Stage Manager](https://hire.apploi.com/applicantStatusManager) page of the Apploi platform in which custom application statuses can be created. The value of this field is case-sensitive: it must precisely match the name of the status in the Apploi platform. If the `interview` key is present in the request, the value of this field will be ignored and the status of the candidate's application will be automatically set to 'Interview Scheduled'.\n\nexamples: `New`, `Interview Scheduled`, `Hired`, `Rejected`, etc.",
            "type": "string"
          },
          "appliedOnMillis": {
            "default": 1672531199000,
            "description": "Timestamp of the application",
            "type": "integer"
          },
          "get_person_token": {
            "default": true,
            "description": "True to get the person token to use later to obtain the basic info of the applicant.",
            "type": "boolean"
          },
          "id": {
            "default": "12345",
            "description": "The id of the application in the external service",
            "type": "string"
          },
          "interview": {
            "description": "An interview information object used to schedule an interview when the application is created. If this field is present in the request, the status of the candidate's application will be automatically set to 'Interview Scheduled'. This will override the value of the `applicant_status` field if it is also present in the request. ",
            "properties": {
              "date": {
                "description": "Interview date and time, specified in ISO 8601 format. Non-ISO 8601 format date-time strings are not allowed. The timezone information provided in this value will be overridden by the value provided in the `timezone` field. However, this field still requires timezone information to be present, so simply appending `Z` at the end of the date-time string is sufficient.\n\nExamples: `\"2021-03-25T10:00:00Z\"`, `\"2024-10-22T14:00:00Z\"`, etc.",
                "format": "date-time",
                "type": "string"
              },
              "duration": {
                "default": "60",
                "description": "The interview duration in minutes. The type of this field is a numeric integer string. Non-numeric string characters are not allowed.\n\nExamples: `\"30\"`, `\"60\"`, `\"90\"`, etc.",
                "type": "string"
              },
              "interviewerId": {
                "default": "123456",
                "description": "The User ID of the interviewer in the Apploi platform. This field must be an integer string value. Non-integer string characters are not allowed. This is the user ID of a team member recorded in the Apploi platform. Reaching out to the Apploi support team may be the best way to get the correct user ID for the interviewer.\n\nExamples: `\"123456\"`, `\"789012\"`, etc.",
                "type": "string"
              },
              "location": {
                "default": "Virtual",
                "description": "The location of the interview. The only restriction on this field is that it must be a string. This allows for specifying a physical location, a virtual location, or any other type of location.\n\nExamples: `\"123 Main St, New York, NY 10001\"`, `\"Virtual\"`, `\"https://meet.google.com/abc-123-xyz\"`, etc.",
                "type": "string"
              },
              "timezone": {
                "default": "America/New_York",
                "description": "The timezone of the interview date and time. The timezone must be a valid timezone string as defined by the [IANA Time Zone Database](https://www.iana.org/time-zones). This timezone will override any timezone information specified in the date field.\n\nExamples: `\"America/New_York\"`, `\"Europe/London\"`, `\"Asia/Tokyo\"`, etc.",
                "type": "string"
              }
            },
            "required": [
              "date",
              "duration",
              "interviewerId",
              "timezone"
            ],
            "type": "object"
          },
          "job": {
            "description": "Job information object",
            "properties": {
              "jobId": {
                "default": "67890",
                "description": "Job ID in Apploi platform",
                "type": "string"
              }
            },
            "required": [
              "jobId"
            ],
            "type": "object"
          },
          "partner_attributes": {
            "description": "Metadata related to the job and the origin of the application.",
            "properties": {
              "sponsored": {
                "default": false,
                "description": "True if the job is sponsored.",
                "type": "boolean"
              }
            },
            "type": "object"
          },
          "questions": {
            "properties": {
              "answers": {
                "description": "Answers information object",
                "items": {
                  "oneOf": [
                    {
                      "required": [
                        "value"
                      ],
                      "type": "object"
                    },
                    {
                      "required": [
                        "values"
                      ],
                      "type": "object"
                    }
                  ],
                  "properties": {
                    "id": {
                      "default": "1",
                      "description": "Id of question.",
                      "type": "string"
                    },
                    "value": {
                      "default": "Yes",
                      "description": "Answer value, It is used in answer type textarea, text, date, select",
                      "type": "string"
                    },
                    "values": {
                      "description": "Answer value, It is used only for multiselect answer type.",
                      "items": {
                        "type": "string"
                      },
                      "type": "array"
                    }
                  },
                  "required": [
                    "id"
                  ],
                  "type": "object"
                },
                "required": [
                  "answers"
                ],
                "type": "array"
              }
            },
            "type": "object"
          }
        },
        "required": [
          "applicant",
          "job",
          "partner_attributes"
        ],
        "type": "object"
      },
      "Empty": {
        "title": "Empty Schema",
        "type": "object"
      }
    },
    "securitySchemes": {
      "api_key": {
        "in": "header",
        "name": "x-api-key",
        "type": "apiKey"
      }
    }
  },
  "info": {
    "title": "Partner API",
    "version": "2026-09-22T01:26:22Z"
  },
  "openapi": "3.0.1",
  "paths": {
    "/easy-apply": {
      "post": {
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/EasyApplyUTMAndResume"
              }
            }
          },
          "description": "Pass in a JSON body with applicant details in this format: \n\n\n        \n\n\n        {\n            \"id\": \"12345\",\n            \"get_person_token\": True,\n            \"partner_attributes\": {\n                \"sponsored\": false,\n            },\n            \"applicant_status\": \"New\",\n            \"applicant\": {\n                \"email\": \"john.doe@example.com\",\n                \"fullName\": \"John Doe\",\n                \"phoneNumber\": \"123-456-7890\",\n                \"source\": \"linkedin\",\n                \"utm_source\": \"linkedin\",\n                \"utm_medium\": \"social\",\n                \"utm_campaign\": \"spring_campaign\",\n                \"resume\": {\n                    \"file\": {\n                        \"fileName\": \"resume.pdf\",\n                        \"contentType\": \"application/pdf\",\n                        \"data\": \"base64_encoded_resume_content\",\n                    }\n                },\n            },\n            \"appliedOnMillis\": 1672531199000,\n            \"job\": {\n                \"jobId\": \"67890\"\n            },\n            \"questions\": {\n                \"answers\": [\n                    {\n                        \"id\": \"1\",\n                        \"value\": \"Yes\"\n                    },\n                    {\n                        \"id\": \"2\",\n                        \"values\": [\"Option1\", \"Option2\"]\n                    }\n                ]\n            },\n            \"interview\": {\n                \"date\": \"2024-10-22T14:00:00Z\",\n                \"duration\": \"60\",\n                \"timezone\": \"America/New_York\",\n                \"location\": \"Virtual\",\n                \"interviewerId\": \"123\"\n            }\n        }\n        ",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Empty"
                }
              }
            },
            "description": "200 response"
          },
          "409": {
            "content": {},
            "description": "Duplicate application: We define duplicate as an application from the same job seeker email, to the same jobid"
          },
          "410": {
            "content": {},
            "description": "If a job post is expired or no longer available."
          },
          "503": {
            "content": {},
            "description": "request took longer than 30 seconds to complete."
          }
        },
        "security": [
          {
            "api_key": []
          }
        ],
        "x-amazon-apigateway-integration": {
          "httpMethod": "POST",
          "passthroughBehavior": "when_no_match",
          "responses": {
            "default": {
              "statusCode": "200"
            }
          },
          "timeoutInMillis": 29000,
          "type": "http_proxy",
          "uri": "https://${stageVariables.integrations}/v1/application/easy-apply/"
        },
        "parameters": [],
        "summary": "/easy-apply",
        "x-internal": false
      }
    }
  },
  "servers": [
    {
      "url": "https://partners.apploi.com"
    }
  ],
  "x-amazon-apigateway-documentation": {
    "createdDate": "2026-09-22T01:29:07Z",
    "documentationParts": [
      {
        "location": {
          "path": "/jobs/cities",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "Cities and States mapping. Every incoming request to the API must contain an API key. Otherwise, the caller receives a 403 Forbidden response."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/jobs/cities",
          "type": "METHOD"
        },
        "properties": {
          "description": "Return the list of cities. All parameters are optional, but if used then this will return only cities that has jobs matching the given params."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "location",
          "path": "/jobs/cities",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "GPS coordinates of the location using the format 'lat,long' for example: 25.7616798,-80.1917902"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "radius",
          "path": "/jobs/cities",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Radius distance in miles from the location coordinates, by default is 10mi. Only used if location is specified."
        }
      },
      {
        "location": {
          "path": "/jobs/industries",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "Industries mapping. Every incoming request to the API must contain an API key. Otherwise, the caller receives a 403 Forbidden response."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/jobs/industries",
          "type": "METHOD"
        },
        "properties": {
          "description": "Return the list of industries. All parameters are optional, but if used then this will return only industries that has jobs matching the given params."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "city",
          "path": "/jobs/industries",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Name of the city"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "location",
          "path": "/jobs/industries",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "GPS coordinates of the location using the format 'lat,long' for example: 25.7616798,-80.1917902"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "radius",
          "path": "/jobs/industries",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Radius distance in miles from the location coordinates, by default is 10mi. Only used if location is specified."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "state",
          "path": "/jobs/industries",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Name of the state of the city"
        }
      },
      {
        "location": {
          "path": "/jobs/search",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "Used for lookup one job or a group of them using an specific criteria (location, keywords, etc.). Every incoming request to the API must contain an API key. Otherwise, the caller receives a 403 Forbidden response."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/jobs/search",
          "type": "METHOD"
        },
        "properties": {
          "description": "Used for retrieving all the jobs that match the specified criteria"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "city",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Name of the city to filter. example: Houston"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "city_center",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Name of the city, Parameter used to group the statistics by city. example: Chicago"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "include_backfilling",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Use 1 (default) to include backfilling jobs on the result. Use 0 to exclude backfilling jobs and include only Apploi jobs."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "include_private",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Set to 1 to include private (hidden) jobs in results. By default (0), only public jobs are returned."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "industry",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Name of the industry to filter, should be in English, if it is more than one, use commas to separate. example: Retail,Healthcare,Other"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "job_id",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Id of the job. If present the request will return only the specified job (if found)"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "language",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Language to use for search, this parameter is added to the property redirect_apply_url for apploi jobs. The allowed values  are (en|es), By default the value for language is en. Example: language=es. "
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "location",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "GPS coordinates of the location using the format 'lat,long' for example: 25.7616798,-80.1917902"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "location_filter",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Use 0 (default) for only sorting by location. Use 1 for filtering by location. into the <radius> param."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "location_sort",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Use 0 (default) to filter by location. \nUse 1 to sort without filtering by location."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "page",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Page number (starts in 1), each page has 50 results."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "radius",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Radius distance in miles from the location coordinates"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "searchbar",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Keyword(s) to use on the search"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "size",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Amount of jobs to return. The maximum number of returned jobs is 1000."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "source",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Partner name"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "source_tracking_string",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Identifies which site sent the traffic"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "state",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Name of the state to filter. example: Texas"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "teams",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "id of the team or teams to search the apploi jobs, if it is more than one, use commas to separate. example: teams=30463,30464"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "test_q_param",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "test doc for q string param"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "utm_campaign",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Identifies a specific product promotion or strategic campaign."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "utm_medium",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Identifies what type of link was used, such as cost per click or email."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "utm_source",
          "path": "/jobs/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Identifies which site sent the traffic"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "x-api-key",
          "path": "/jobs/search",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "*",
          "name": "job_id",
          "path": "/jobs",
          "type": "PATH_PARAMETER"
        },
        "properties": {
          "description": "the job identification number"
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/jobs",
          "type": "METHOD"
        },
        "properties": {
          "description": "Creates a new job posting. If you are looking to utilize this endpoint, please reach out to your CSM or support to approve your access."
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/jobs",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Invalid Token"
        }
      },
      {
        "location": {
          "method": "*",
          "name": "job_id",
          "path": "/jobs/{job_id}",
          "type": "PATH_PARAMETER"
        },
        "properties": {
          "description": "the job identification number"
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/jobs/{job_id}",
          "type": "METHOD"
        },
        "properties": {
          "description": "Update an existing job posting. All fields are optional; only provided fields are updated. team_id is not updatable. The address is the exception to the field-by-field rule: it is stored as a single value, so supplying city, state, zip_code and country replaces the whole address. Send street in the same request to keep it. Sending street on its own, without city, state, zip_code and country, does not update the stored address. If you are looking to utilize this endpoint, please reach out to your CSM or support to approve your access."
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/jobs/{job_id}",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Invalid Token"
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/jobs/{job_id}",
          "statusCode": "404",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Not Found"
        }
      },
      {
        "location": {
          "method": "*",
          "name": "team_id",
          "path": "/jobs/ai_chat/subscription/{team_id}",
          "type": "PATH_PARAMETER"
        },
        "properties": {
          "description": "The ID of the team that the jobs belong to."
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/jobs/ai_chat/subscription/{team_id}",
          "type": "METHOD"
        },
        "properties": {
          "description": "Updates job AT chat feature for a specific team."
        }
      },
      {
        "location": {
          "method": "PUT",
          "name": "x-api-key",
          "path": "/jobs/ai_chat/subscription/{team_id}",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/jobs/ai_chat/subscription/{team_id}",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Invalid Token"
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/jobs/ai_chat/subscription/{team_id}",
          "statusCode": "404",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Not Found"
        }
      },
      {
        "location": {
          "method": "*",
          "name": "team_id",
          "path": "/jobs/job_attributes/{team_id}",
          "type": "PATH_PARAMETER"
        },
        "properties": {
          "description": "the id of the team that the job attributes belong to"
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/jobs/job_attributes/{team_id}",
          "type": "METHOD"
        },
        "properties": {
          "description": "Creates or updates job attributes for a specific team."
        }
      },
      {
        "location": {
          "method": "POST",
          "name": "x-api-key",
          "path": "/jobs/job_attributes/{team_id}",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/jobs/job_attributes/{team_id}",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Invalid Token"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "limit",
          "path": "/applicants",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "The maximum number of applicants to return in a single response. Defaults to `30`. The maximum is `80`: a `limit` that is not a whole number between `1` and `80` is not rejected — it is served as `80`, so a response may contain fewer applicants than you asked for. Use `offset` to page through large result sets."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "offset",
          "path": "/applicants",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "The number of applicants to skip before returning results, used for pagination. Defaults to `0`. To page through all applicants, increment `offset` by `limit` on each request (e.g. `limit=50&offset=0`, then `limit=50&offset=50`, ...) until a page returns fewer than `limit` results."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "updated_after",
          "path": "/applicants",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Filter to include only applicants that were updated after the given date. By using the `updated_after` and `updated_before` filters together, entries returned in the response can be filtered by a window of time in which they were most recently updated.\nThe values provided in the filter must be in one of the following formats:\n```plaintext\n• Dates in the format of YYYY-MM-DD\n    • examples: `2024-10-29`, `2017-09-28`, `2020-01-01`\n• Date-times in isoformat, with or without timezone information.\n    • If timezone information is excluded, then UTC will be assumed.\n    • examples: `2024-10-29T10:00:00`, `2024-10-29T10:00:00Z`, `2024-10-29T10:00:00+00:00`\n```\n"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "updated_before",
          "path": "/applicants",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Filter to include only applicants that were updated before the given date. By using the `updated_after` and `updated_before` filters together, entries returned in the response can be filtered by a window of time in which they were most recently updated.\nThe values provided in the filter must be in one of the following formats:\n```plaintext\n• Dates in the format of YYYY-MM-DD\n    • examples: `2024-10-29`, `2017-09-28`, `2020-01-01`\n• Date-times in isoformat, with or without timezone information.\n    • If timezone information is excluded, then UTC will be assumed.\n    • examples: `2024-10-29T10:00:00`, `2024-10-29T10:00:00Z`, `2024-10-29T10:00:00+00:00`\n```\n"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "x-api-key",
          "path": "/applicants",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "*",
          "name": "applicant_id",
          "path": "/applicants/{applicant_id}",
          "type": "PATH_PARAMETER"
        },
        "properties": {
          "description": "The application form ID corresponding to a job application in the Apploi platform. The application form ID is a unique identifier for the job application in the Apploi platform. The application form ID can be found in the 'id' field of the each of the items in the response body of a call to the [/applicants](https://integrate.apploi.com/reference/get_applicants) endpoint in the Apploi Partner API.\n\nExamples: `265733753`, `265733754`, etc."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/{applicant_id}",
          "type": "METHOD"
        },
        "properties": {
          "description": "Endpoint for retrieving a processed application. This endpoint allows users to fetch the current details of a specific candidate's application for a specific job, including the applicant's status, notes, and other application data."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "include_sensitive_data",
          "path": "/applicants/{applicant_id}",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "When set to `true`, the response includes additional sensitive candidate data (for example, Social Security Number and date of birth) if this has been enabled for the requesting team. Defaults to `false` when omitted.\n\nExamples: `true`, `false`"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "x-api-key",
          "path": "/applicants/{applicant_id}",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/{applicant_id}",
          "statusCode": "200",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Returns the current details of the requested candidate's application, including its status, notes, and other application data."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/{applicant_id}",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Invalid Token"
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/{applicant_id}",
          "statusCode": "404",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Not Found"
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/applicants/{applicant_id}",
          "type": "METHOD"
        },
        "properties": {
          "description": "Endpoint for updating a processed application. This endpoint allows users to modify the properties of a specific candidate's application for a specific job."
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/applicants/{applicant_id}",
          "type": "REQUEST_BODY"
        },
        "properties": {
          "description": "Pass in a JSON body with application details in this format: \n\n\n        {\n          \"notes\": \"Applicant has strong experience in healthcare.\"\n        }\n        "
        }
      },
      {
        "location": {
          "method": "PUT",
          "name": "x-api-key",
          "path": "/applicants/{applicant_id}",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/applicants/{applicant_id}",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Invalid Token"
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/applicants/{applicant_id}",
          "statusCode": "404",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Not Found"
        }
      },
      {
        "location": {
          "path": "/applicants/{applicant_id}/interviews",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "Endpoint for scheduling or cancelling interviews for candidates. This endpoint allows the creation of interview appointments for a specific applicant and job. If the API is called again for the same candidate and job combination, the existing interview details will be updated with the newly provided information, effectively acting as an update operation. It cancels the latest created upcoming interview when the `cancel` flag is set to `true`. When cancelling, all other fields in the request body are ignored."
        }
      },
      {
        "location": {
          "method": "*",
          "name": "applicant_id",
          "path": "/applicants/{applicant_id}/interviews",
          "type": "PATH_PARAMETER"
        },
        "properties": {
          "description": "The application form ID corresponding to a job application in the Apploi platform. The application form ID is a unique identifier for the job application in the Apploi platform. The application form ID can be found in the 'id' field of the each of the items in the response body of a call to the [/applicants](https://integrate.apploi.com/reference/get_applicants) endpoint in the Apploi Partner API.\n\nExamples: `265733753`, `265733754`, etc."
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/applicants/{applicant_id}/interviews",
          "type": "METHOD"
        },
        "properties": {
          "description": "Endpoint for scheduling or cancelling interviews for candidates. This endpoint allows the creation of interview appointments for a specific applicant and job. If the API is called again for the same candidate and job combination, the existing interview details will be updated with the newly provided information, effectively acting as an update operation. It cancels the latest created upcoming interview when the `cancel` flag is set to `true`. When cancelling, all other fields in the request body are ignored."
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/applicants/{applicant_id}/interviews",
          "type": "REQUEST_BODY"
        },
        "properties": {
          "description": "Pass in a JSON body with interview details. Either `interviewerId` must be provided, or both `interviewerTeamId` and `interviewerEmail` must be provided.\n\n**Option 1: Using interviewerId**\n\n```\n{\n    \"date\": \"2022-12-05T17:30:00Z\",\n    \"duration\": \"60\",\n    \"timezone\": \"America/New_York\",\n    \"location\": \"Virtual\",\n    \"interviewerId\": \"123456\"\n}\n```\n\n**Option 2: Using interviewerTeamId and interviewerEmail**\n\n```\n{\n    \"date\": \"2022-12-05T17:30:00Z\",\n    \"duration\": \"60\",\n    \"timezone\": \"America/New_York\",\n    \"location\": \"Virtual\",\n    \"interviewerEmail\": \"interviewer@apploi.com\",\n    \"interviewerTeamId\": \"23567\"\n}\n```\n\n**Option 3: Cancelling the latest interview**\n\n*Note: Scheduling fields are still required by the schema but will be ignored by the service when `cancel` is `true`.*\n\n```\n{\n    \"date\": \"2022-12-05T17:30:00Z\",\n    \"duration\": \"60\",\n    \"timezone\": \"America/New_York\",\n    \"interviewerId\": \"123456\",\n    \"cancel\": true\n}\n```"
        }
      },
      {
        "location": {
          "method": "PUT",
          "name": "x-api-key",
          "path": "/applicants/{applicant_id}/interviews",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/applicants/{applicant_id}/interviews",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Invalid Token"
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/applicants/{applicant_id}/interviews",
          "statusCode": "404",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Not Found"
        }
      },
      {
        "location": {
          "path": "/applicants/{applicant_id}/message",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "Message endpoints for applicant communication. Provides methods to retrieve and create messages for applications. Supports both text (SMS) and email messages. All messages are associated with AI-based candidate messaging features."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/{applicant_id}/message",
          "type": "METHOD"
        },
        "properties": {
          "description": "Retrieves all messages for a specific application. Returns both messages sent to the candidate (outbound) and responses from the candidate (inbound). Messages are ordered by sent date, newest first. \n\n**Authentication:** Requires valid x-api-key header.\n\n**Response Example:**\n```json\n{\n  \"data\": [\n    {\n      \"external_id\": \"uuid123456\",\n      \"message_id\": \"msg001\",\n      \"message_body\": \"Thank you for applying! We'd like to schedule an interview.\",\n      \"message_direction\": \"to_candidate\",\n      \"message_type\": \"text\",\n      \"sent_at\": \"Thu, 23 Oct 2025 13:12:47 GMT\",\n      \"status\": \"SENT\",\n      \"subject\": null\n    },\n    {\n      \"external_id\": \"response789012\",\n      \"message_id\": \"msg002\",\n      \"message_body\": \"I am available for an interview next week.\",\n      \"message_direction\": \"from_candidate\",\n      \"message_type\": \"text\",\n      \"sent_at\": \"Thu, 23 Oct 2025 13:12:47 GMT\",\n      \"status\": \"DELIVERED\",\n      \"subject\": null\n    },\n    {\n      \"external_id\": \"response789015\",\n      \"message_id\": \"msg005\",\n      \"message_body\": \"Hey your interview is scheduled for next week.\",\n      \"message_direction\": \"to_candidate\",\n      \"message_type\": \"email\",\n      \"sent_at\": \"Thu, 23 Oct 2025 13:12:47 GMT\",\n      \"status\": \"DELIVERED\",\n      \"subject\": \"Interview Scheduled\"\n    },\n  ]\n}\n```"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "applicant_id",
          "path": "/applicants/{applicant_id}/message",
          "type": "PATH_PARAMETER"
        },
        "properties": {
          "description": "The application form ID corresponding to a job application in the Apploi platform. The application form ID is a unique identifier for the job application in the Apploi platform. The application form ID can be found in the 'id' field of the each of the items in the response body of a call to the [/applicants](https://integrate.apploi.com/reference/get_applicants) endpoint in the Apploi Partner API.\n\nExamples: `265733753`, `265733754`, etc."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "x-api-key",
          "path": "/applicants/{applicant_id}/message",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/applicants/{applicant_id}/message",
          "type": "METHOD"
        },
        "properties": {
          "description": "Creates a new message for a specific application. Messages can be sent to the candidate (outbound) or recorded as responses from the candidate (inbound). Supports both text (SMS) and email message types. \n\n**Message Direction:** \n- 'to_candidate': Outbound messages sent to the candidate (e.g., from AI system)\n- 'from_candidate': Inbound messages/responses from the candidate\n\n**Message Delivery Control:** \n- `is_sent_by_vendor`: default true if not sent in payload\n- `is_sent_by_vendor=true`: Vendor handles message delivery\n- `is_sent_by_vendor=false`: Apploi sends the message via SMS/Email infrastructure\n\n**Email Requirements:** When message_type is 'email', the 'subject' field is required.\n\n**Authentication:** Requires valid x-api-key header."
        }
      },
      {
        "location": {
          "method": "POST",
          "name": "applicant_id",
          "path": "/applicants/{applicant_id}/message",
          "type": "PATH_PARAMETER"
        },
        "properties": {
          "description": "The application form ID corresponding to a job application in the Apploi platform. The application form ID is a unique identifier for the job application in the Apploi platform. The application form ID can be found in the 'id' field of the each of the items in the response body of a call to the [/applicants](https://integrate.apploi.com/reference/get_applicants) endpoint in the Apploi Partner API.\n\nExamples: `265733753`, `265733754`, etc."
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/applicants/{applicant_id}/message",
          "type": "REQUEST_BODY"
        },
        "properties": {
          "description": "Pass in a JSON body with message details. All fields are required except 'subject' when message_type is 'text'. \n\n**Required Fields:**\n- external_id: Vendor-specific message identifier\n- message_type: 'text' or 'email'\n- message_body: Message content\n- status: Message status (e.g., 'SENT', 'DELIVERED')\n- vendor_name: Vendor/service name (e.g., 'abc')\n- message_direction: 'to_candidate' or 'from_candidate'\n- sender_email: Email address of the message sender. It is required depending on vendor configuration. This email address should match to the user in Apploi for the team.\n\n**Optional Fields:**\n- subject: Required when message_type is 'email'\n- is_sent_by_vendor: Boolean flag (true = vendor sends, false = Apploi sends) default value is true if not passed in payload\n\n**Example - Text Message to Candidate (Vendor Sends):**\n```json\n{\n  \"external_id\": \"uuid-123-456\",\n  \"message_type\": \"text\",\n  \"message_body\": \"Thank you for applying! We'd like to schedule an interview.\",\n  \"status\": \"SENT\",\n  \"vendor_name\": \"abc\",\n  \"message_direction\": \"to_candidate\",\n  \"is_sent_by_vendor\": true,\n  \"sender_email\": \"recruiter@example.com\"\n}\n```\n\n**Example - Email to Candidate (Apploi Sends):**\n```json\n{\n  \"external_id\": \"email-456-789\",\n  \"message_type\": \"email\",\n  \"message_body\": \"We are excited to move forward with your application...\",\n  \"subject\": \"Interview Invitation\",\n  \"status\": \"SENT\",\n  \"vendor_name\": \"abc\",\n  \"message_direction\": \"to_candidate\",\n  \"is_sent_by_vendor\": false,\n  \"sender_email\": \"recruiter@example.com\"\n}\n```\n\n**Example - Response from Candidate (No Optional Fields):**\n```json\n{\n  \"external_id\": \"response-789-012\",\n  \"message_type\": \"text\",\n  \"message_body\": \"I am available for an interview next week.\",\n  \"status\": \"DELIVERED\",\n  \"vendor_name\": \"abc\",\n  \"message_direction\": \"from_candidate\"\n}\n```"
        }
      },
      {
        "location": {
          "method": "POST",
          "name": "x-api-key",
          "path": "/applicants/{applicant_id}/message",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/basic-info",
          "type": "METHOD"
        },
        "properties": {
          "description": "Return email, first name, last name, home phone number, mobile phone number, and resume file name information for a specific applicant using the token returned by the `/easy-apply` endpoint."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "Authorization",
          "path": "/applicants/basic-info",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "**Deprecated: `Authorization`-header authentication is being sunset.** This flow is affected as part of that sunset — watch for a follow-up communication with details and timelines. The bearer token retrieved from the response to a successful call to the `/easy-apply` endpoint, when submitting a candidate application. This token should be passed in the 'Authorization' header in the following format: 'Bearer <token>'."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/already-applied/{job_id}",
          "type": "METHOD"
        },
        "properties": {
          "description": "Return information if the person has already applied for the job associated with the provided {job_id}."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "Authorization",
          "path": "/applicants/already-applied/{job_id}",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "**Deprecated: `Authorization`-header authentication is being sunset.** This flow is affected as part of that sunset — watch for a follow-up communication with details and timelines. The bearer token retrieved from the response to a successful call to the `/easy-apply` endpoint, when submitting a candidate application. This token should be passed in the 'Authorization' header in the following format: 'Bearer <token>'."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/already-applied/{job_id}",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Invalid Token"
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/already-applied/{job_id}",
          "statusCode": "404",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Not Found"
        }
      },
      {
        "location": {
          "path": "/applicants/preconfigured-documents/{applicant_id}",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "Downloads a candidate's completed preconfigured documents as a single zip archive. \n\nPreconfigured documents are the document templates your team has set up in Apploi. This endpoint returns the individual files pulled out of those documents once the candidate has completed them, bundled into one archive and served as an attachment named `files.zip`. \n\nWhich templates are covered, and which files are extracted from each, is part of your team's document configuration in Apploi rather than something you select per request. A team with no such configuration set up — and no parent team configuration to fall back on — gets a `404` from this endpoint rather than an empty archive. \n\nOnly documents the candidate has actually completed are included. An application whose documents are still outstanding also returns a `404`, so a `404` here does not necessarily mean the application does not exist. A `200` is not a guarantee of content either: when the candidate has completed documents but none of the files configured for them are found, the archive comes back empty. \n\nAccess is authorized per candidate: the caller must have permission on the job the candidate applied to, otherwise the request is rejected with a `403`. \n\nEvery request to this endpoint must include your Apploi-issued API key in the `x-api-key` header."
        }
      },
      {
        "location": {
          "method": "*",
          "name": "applicant_id",
          "path": "/applicants/preconfigured-documents/{applicant_id}",
          "type": "PATH_PARAMETER"
        },
        "properties": {
          "description": "The application form ID corresponding to a job application in the Apploi platform. The application form ID is a unique identifier for the job application in the Apploi platform. The application form ID can be found in the 'id' field of the each of the items in the response body of a call to the [/applicants](https://integrate.apploi.com/reference/get_applicants) endpoint in the Apploi Partner API.\n\nExamples: `265733753`, `265733754`, etc."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/preconfigured-documents/{applicant_id}",
          "type": "METHOD"
        },
        "properties": {
          "description": "Downloads a candidate's completed preconfigured documents as a single zip archive. \n\nPreconfigured documents are the document templates your team has set up in Apploi. This endpoint returns the individual files pulled out of those documents once the candidate has completed them, bundled into one archive and served as an attachment named `files.zip`. \n\nWhich templates are covered, and which files are extracted from each, is part of your team's document configuration in Apploi rather than something you select per request. A team with no such configuration set up — and no parent team configuration to fall back on — gets a `404` from this endpoint rather than an empty archive. \n\nOnly documents the candidate has actually completed are included. An application whose documents are still outstanding also returns a `404`, so a `404` here does not necessarily mean the application does not exist. A `200` is not a guarantee of content either: when the candidate has completed documents but none of the files configured for them are found, the archive comes back empty. \n\nAccess is authorized per candidate: the caller must have permission on the job the candidate applied to, otherwise the request is rejected with a `403`. \n\nEvery request to this endpoint must include your Apploi-issued API key in the `x-api-key` header."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "x-api-key",
          "path": "/applicants/preconfigured-documents/{applicant_id}",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/preconfigured-documents/{applicant_id}",
          "statusCode": "200",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "The documents, as a zip archive served with `Content-Type: application/zip` and a `Content-Disposition` attachment filename of `files.zip`. The body is binary, not JSON."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/preconfigured-documents/{applicant_id}",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "The request was rejected before the archive could be assembled, either because the caller has no permission on the job this candidate applied to or because the API key's user lacks the file-download permission. The body depends on where the rejection happened: a missing or unrecognized `x-api-key` header is rejected by the API gateway itself, which returns `{\"message\": \"Forbidden\"}`, while a rejection further in returns `{\"developer_message\": ...}`."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/preconfigured-documents/{applicant_id}",
          "statusCode": "404",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Returned for four distinct reasons:\n- No application exists with the given `applicant_id`.\n- The `applicant_id` in the path was not an integer.\n- Your team, and its parent team, have no document configuration set up for this endpoint. This is the only one of the four with a `developer_message` that identifies it: `Endpoint not configured for this team`.\n- The candidate has no completed documents to return.\n\nThe `developer_message` does not reliably tell the other three apart, so do not branch on it. The last two reasons mean the application exists and is readable but has nothing to download, so treat a `404` here as an empty result rather than as a missing application."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/preconfigured-documents/{applicant_id}",
          "statusCode": "500",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "The archive could not be assembled because of an error on Apploi's side. The request can safely be retried. Note that any document already read before the error is recorded as downloaded in the candidate's activity log, so a failed request and its retry can each leave entries behind."
        }
      },
      {
        "location": {
          "path": "/applicants/files/{applicant_id}",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "Endpoint for downloading every file attached to a candidate's application as a single zip archive. This endpoint returns the files a candidate uploaded during the application process, such as resumes, certifications and licences, bundled into one archive served as an attachment. If the candidate exists but has no files attached, the request still succeeds with a `200`, and the body is a short JSON message instead of an archive. Callers should therefore check the response `Content-Type` before treating the body as binary. Access is authorised per candidate: the caller must have permission on the job the candidate applied to, otherwise the request is rejected with a `403`."
        }
      },
      {
        "location": {
          "method": "*",
          "name": "applicant_id",
          "path": "/applicants/files/{applicant_id}",
          "type": "PATH_PARAMETER"
        },
        "properties": {
          "description": "The application form ID corresponding to a job application in the Apploi platform. The application form ID is a unique identifier for the job application in the Apploi platform. The application form ID can be found in the 'id' field of the each of the items in the response body of a call to the [/applicants](https://integrate.apploi.com/reference/get_applicants) endpoint in the Apploi Partner API.\n\nExamples: `265733753`, `265733754`, etc."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/files/{applicant_id}",
          "type": "METHOD"
        },
        "properties": {
          "description": "Endpoint for downloading every file attached to a candidate's application as a single zip archive. This endpoint returns the files a candidate uploaded during the application process, such as resumes, certifications and licences, bundled into one archive served as an attachment. If the candidate exists but has no files attached, the request still succeeds with a `200`, and the body is a short JSON message instead of an archive. Callers should therefore check the response `Content-Type` before treating the body as binary. Access is authorised per candidate: the caller must have permission on the job the candidate applied to, otherwise the request is rejected with a `403`."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "x-api-key",
          "path": "/applicants/files/{applicant_id}",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/files/{applicant_id}",
          "statusCode": "200",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Files downloaded as a zip archive, or a JSON message when the candidate has no files. Check the response `Content-Type` before treating the body as binary."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/files/{applicant_id}",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Invalid Token"
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/files/{applicant_id}",
          "statusCode": "404",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Not Found"
        }
      },
      {
        "location": {
          "path": "/applicants/backgroundcheckresult",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "Endpoint for updating background check results for a candidate. This endpoint allows the submission of background check results for a specific applicant.\n\n Note: Every incoming request to the API must contain an API key. The request must include the applicant's ID and the background check result details in JSON format."
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/applicants/backgroundcheckresult",
          "type": "METHOD"
        },
        "properties": {
          "description": "Endpoint for updating background check results for a candidate. This endpoint allows the submission of background check results for a specific applicant.\n\n Note: Every incoming request to the API must contain an API key. The request must include the applicant's ID and the background check result details in JSON format."
        }
      },
      {
        "location": {
          "method": "POST",
          "name": "x-api-key",
          "path": "/applicants/backgroundcheckresult",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "path": "/applicants/status",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "This endpoint is used to update the status of job applications. It can be used to update the status of a single application or multiple applications at once, depending on the request body."
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/applicants/status",
          "type": "METHOD"
        },
        "properties": {
          "description": "This endpoint is used to update the status of job applications. It can be used to update the status of a single application or multiple applications at once, depending on the request body."
        }
      },
      {
        "location": {
          "method": "PUT",
          "name": "x-api-key",
          "path": "/applicants/status",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "PUT",
          "path": "/applicants/status",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Invalid Token"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "team_id",
          "path": "/applicants/applicant-statuses",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "This ID is used to identify the specific `team` record in the Apploi platform which owns the application statuses being queried. \n\nThis ID is assigned by Apploi automatically when a `team` record is first created and is unique to each team. The value of the `team_id` can be found in each of the items returned in the response data of a call to the [/applicants](https://integrate.apploi.com/reference/get_applicants) endpoint. If the JSON body of the response were assigned to a variable called `response` then the team ID for the first item could be accessed through the following nested attribute reference: `response.data[0].job.team_id`(JavaScript), `response['data'][0]['job']['team_id']`(Python). When fetching the available application statuses for the purpose of updating the status of specific job applications, the `team_id` should be the same as the one found in a response from a call to the [/applicants](https://integrate.apploi.com/reference/get_applicants) endpoint.\n\nExamples: `123456`, `789012`"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "Authorization",
          "path": "/applicants/applicant-statuses",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "**Deprecated: `Authorization`-header authentication is being sunset** in favor of `x-api-key` authentication, which is now the standard way to authenticate with the Partner API. New integrations should use `x-api-key` instead — watch for a follow-up communication with removal timelines. The bearer token provided by the `/easy-apply` and/or `/v1/users/login` endpoints (depending on the use case). This token should be passed in the 'Authorization' header in the following format: 'Bearer <token>'."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "x-api-key",
          "path": "/applicants/applicant-statuses",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/applicants/applicant-statuses",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Invalid Token"
        }
      },
      {
        "location": {
          "path": "/easy-apply",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "Endpoint for uploading applicants into Apploi platform. Note: Every incoming request to the API must contain an API key. Otherwise, the caller receives a 403 Forbidden response."
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/easy-apply",
          "type": "REQUEST_BODY"
        },
        "properties": {
          "description": "Pass in a JSON body with applicant details in this format: \n\n\n        \n\n\n        {\n            \"id\": \"12345\",\n            \"get_person_token\": True,\n            \"partner_attributes\": {\n                \"sponsored\": false,\n            },\n            \"applicant_status\": \"New\",\n            \"applicant\": {\n                \"email\": \"john.doe@example.com\",\n                \"fullName\": \"John Doe\",\n                \"phoneNumber\": \"123-456-7890\",\n                \"source\": \"linkedin\",\n                \"utm_source\": \"linkedin\",\n                \"utm_medium\": \"social\",\n                \"utm_campaign\": \"spring_campaign\",\n                \"resume\": {\n                    \"file\": {\n                        \"fileName\": \"resume.pdf\",\n                        \"contentType\": \"application/pdf\",\n                        \"data\": \"base64_encoded_resume_content\",\n                    }\n                },\n            },\n            \"appliedOnMillis\": 1672531199000,\n            \"job\": {\n                \"jobId\": \"67890\"\n            },\n            \"questions\": {\n                \"answers\": [\n                    {\n                        \"id\": \"1\",\n                        \"value\": \"Yes\"\n                    },\n                    {\n                        \"id\": \"2\",\n                        \"values\": [\"Option1\", \"Option2\"]\n                    }\n                ]\n            },\n            \"interview\": {\n                \"date\": \"2024-10-22T14:00:00Z\",\n                \"duration\": \"60\",\n                \"timezone\": \"America/New_York\",\n                \"location\": \"Virtual\",\n                \"interviewerId\": \"123\"\n            }\n        }\n        "
        }
      },
      {
        "location": {
          "method": "POST",
          "name": "x-api-key",
          "path": "/easy-apply",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/easy-apply",
          "statusCode": "409",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Duplicate application: We define duplicate as an application from the same job seeker email, to the same jobid"
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/easy-apply",
          "statusCode": "410",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "If a job post is expired or no longer available."
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/easy-apply",
          "statusCode": "503",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "request took longer than 30 seconds to complete."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "city",
          "path": "/analytics/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Name of the city to filter. example: Houston"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "industry",
          "path": "/analytics/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Name of the industry to filter, should be in English, if it is more than one, use commas to separate. example: Retail,Healthcare,Other"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "language",
          "path": "/analytics/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Language to use for search, this parameter is added to the property redirect_apply_url for apploi jobs. The allowed values are (en|es), By default the value for language is en. Example: language=es."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "location",
          "path": "/analytics/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "GPS coordinates of the location using the format 'lat,long' for example: 25.7616798,-80.1917902"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "location_filter",
          "path": "/analytics/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Use 0 (default) for only sorting by location. Use 1 for filtering by location. into the param."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "page",
          "path": "/analytics/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Page number (starts in 1), each page has 50 results."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "radius",
          "path": "/analytics/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Radius distance in miles from the location coordinates"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "searchbar",
          "path": "/analytics/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Keyword(s) to use on the search"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "source",
          "path": "/analytics/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Partner name"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "state",
          "path": "/analytics/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Name of the state to filter. example: Texas"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "utm_campaign",
          "path": "/analytics/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Identifies a specific product promotion or strategic campaign."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "utm_medium",
          "path": "/analytics/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Identifies what type of link was used, such as cost per click or email."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "utm_source",
          "path": "/analytics/search",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Identifies which site sent the traffic"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "backfilled",
          "path": "/analytics/job-click",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "backfilled field is provided on the job search results"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "city_center",
          "path": "/analytics/job-click",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Houston or Chicago"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "id",
          "path": "/analytics/job-click",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "the job id"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "redirect_apply_url",
          "path": "/analytics/job-click",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Redirect apply url"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "session_id",
          "path": "/analytics/job-click",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "unique id to indicate the unique user"
        }
      },
      {
        "location": {
          "path": "/documents/templates/{template_id}/mergefields",
          "type": "RESOURCE"
        },
        "properties": {}
      },
      {
        "location": {
          "method": "*",
          "name": "template_id",
          "path": "/documents/templates/{template_id}/mergefields",
          "type": "PATH_PARAMETER"
        },
        "properties": {
          "description": "the alphanumeric template id which belongs to the document template"
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/documents/templates/{template_id}/mergefields",
          "type": "METHOD"
        },
        "properties": {
          "description": "Creates or updates merge fields or variables for a specific document template."
        }
      },
      {
        "location": {
          "method": "POST",
          "name": "x-api-key",
          "path": "/documents/templates/{template_id}/mergefields",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/documents/templates/{template_id}/mergefields",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Invalid Token"
        }
      },
      {
        "location": {
          "path": "/application-form-templates",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "Lists the application form templates available to your team, so you can reference a template when creating a job. \n\nResults include every template owned by your team or, if your team has a parent team, that parent team — regardless of who created the template. The API does not currently restrict results further by creator or by template-sharing settings: any caller authenticated for a team sees the full set of templates owned by that team and its parent team."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/application-form-templates",
          "type": "METHOD"
        },
        "properties": {
          "description": "Lists the application form templates available to your team, so you can reference a template when creating a job. \n\nResults include every template owned by your team or, if your team has a parent team, that parent team — regardless of who created the template. The API does not currently restrict results further by creator or by template-sharing settings: any caller authenticated for a team sees the full set of templates owned by that team and its parent team."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "team_id",
          "path": "/application-form-templates",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "This ID is used to identify the specific `team` record in the Apploi platform whose application form templates are being requested. \n\nThis ID is assigned by Apploi automatically when a `team` record is first created and is unique to each team. The value of the `team_id` can be found in each of the items returned in the response data of a call to the [/applicants](https://integrate.apploi.com/reference/get_applicants) endpoint. If the JSON body of the response were assigned to a variable called `response` then the team ID for the first item could be accessed through the following nested attribute reference: `response.data[0].job.team_id` (JavaScript), `response['data'][0]['job']['team_id']` (Python).\n\nExamples: `123456`, `789012`"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "template_group",
          "path": "/application-form-templates",
          "type": "QUERY_PARAMETER"
        },
        "properties": {
          "description": "Filters the returned templates by which stage of the hiring funnel they belong to. \n\nAccepted values: `First Stage` (the initial application a candidate fills out), `Second Stage` (an optional secondary screener), `Interview Guide` (filled out by the interviewer, not the candidate — `interview_guide` is also accepted as an exact alias), and `Not Interview Guide` (a shorthand for \"every template whose group is set to something other than `Interview Guide`\" — `not_interview_guide` is also accepted as an exact alias). \n\n**Matching is case-sensitive and only recognizes these exact strings** — a value like `interview guide` or `INTERVIEW GUIDE` will not match and returns an empty `data` array rather than an error, the same as any other unrecognized value; an empty result does not necessarily mean your team has no templates. \n\n**`Not Interview Guide` also excludes templates whose group is unset (`null`)**, not only ones set to `Interview Guide` — a team whose templates are all ungrouped can get an empty result from this value even though those same templates are returned when the parameter is omitted entirely. \n\nOmit this parameter to return templates from every group, including ungrouped ones.\n\nExamples: `First Stage`, `Interview Guide`, `Not Interview Guide`"
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "Authorization",
          "path": "/application-form-templates",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "**Deprecated: `Authorization`-header authentication is being sunset** in favor of `x-api-key` authentication, which is now the standard way to authenticate with the Partner API. New integrations should use `x-api-key` instead — watch for a follow-up communication with removal timelines. The bearer token provided by the `/easy-apply` and/or `/v1/users/login` endpoints (depending on the use case). This token should be passed in the 'Authorization' header in the following format: 'Bearer <token>'."
        }
      },
      {
        "location": {
          "method": "GET",
          "name": "x-api-key",
          "path": "/application-form-templates",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/application-form-templates",
          "statusCode": "200",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "A `data` array of application form templates. Note `templateGroup` and `template_group` are the same value under two keys (a legacy artifact) — either can be used."
        }
      },
      {
        "location": {
          "method": "GET",
          "path": "/application-form-templates",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "Invalid Token"
        }
      },
      {
        "location": {
          "path": "/v1/users/login",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "**Deprecated: this endpoint is being sunset.** `/v1/users/login` predates API-key authentication and, along with `Authorization`-header authentication generally, is being phased out now that `x-api-key` is the standard way to authenticate with the Partner API. New integrations should use `x-api-key` authentication instead of this endpoint. Existing integrations using this endpoint should plan to migrate — watch for a follow-up communication with removal timelines.\n\nAPI resource to login and getting a response"
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/v1/users/login",
          "type": "METHOD"
        },
        "properties": {
          "description": "**Deprecated: this endpoint is being sunset** in favor of `x-api-key` authentication and will be removed in a future release. Used for logging into the API and getting a response via POST."
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/v1/users/login",
          "type": "REQUEST_BODY"
        },
        "properties": {
          "description": "Pass in a json body with an email address and a password in this format: {\"email\": \"test@example.com\",\"password\": \"<password>\"}"
        }
      },
      {
        "location": {
          "method": "POST",
          "name": "x-api-key",
          "path": "/v1/users/login",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "The AWS API Key provided by Apploi"
        }
      },
      {
        "location": {
          "path": "/webhook/status/{webhook_id}",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "Reports back to Apploi whether a webhook Apploi sent you was processed successfully on your side. \n\nApploi delivers an outbound webhook to your endpoint when an application reaches a configured state. Once you have finished processing that delivery, call this endpoint to record the outcome against the application it was sent for. The `webhook_id` in the path identifies the webhook configuration, and `applicant_id` in the body identifies the application — together they must match a delivery that Apploi has already made successfully, or the request is rejected with a `400`. \n\nWhen reporting a failure (`status` is `false`), `error_message` is required and must not be blank. \n\nEach call records a new status entry rather than replacing the previous one, so calling this endpoint twice for the same delivery records two entries. \n\nEvery request to this endpoint must include your Apploi-issued API key in the `x-api-key` header."
        }
      },
      {
        "location": {
          "method": "*",
          "name": "webhook_id",
          "path": "/webhook/status/{webhook_id}",
          "type": "PATH_PARAMETER"
        },
        "properties": {
          "description": "The ID of the Apploi webhook configuration whose delivery you are reporting on. A webhook configuration is the endpoint, credentials, and trigger state Apploi uses to notify you, and this ID is assigned by Apploi when that configuration is created. It is supplied to you by Apploi as part of setting up your webhook integration, and is the same value for every delivery from that configuration. \n\nThe webhook configuration identified here must be the one whose delivery for the `applicant_id` in the request body succeeded; if no such delivery is found, the request is rejected with a `400`.\n\nExamples: `42`, `43`"
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/webhook/status/{webhook_id}",
          "type": "METHOD"
        },
        "properties": {
          "description": "Reports back to Apploi whether a webhook Apploi sent you was processed successfully on your side. \n\nApploi delivers an outbound webhook to your endpoint when an application reaches a configured state. Once you have finished processing that delivery, call this endpoint to record the outcome against the application it was sent for. The `webhook_id` in the path identifies the webhook configuration, and `applicant_id` in the body identifies the application — together they must match a delivery that Apploi has already made successfully, or the request is rejected with a `400`. \n\nWhen reporting a failure (`status` is `false`), `error_message` is required and must not be blank. \n\nEach call records a new status entry rather than replacing the previous one, so calling this endpoint twice for the same delivery records two entries. \n\nEvery request to this endpoint must include your Apploi-issued API key in the `x-api-key` header."
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/webhook/status/{webhook_id}",
          "type": "REQUEST_BODY"
        },
        "properties": {
          "description": "Pass in a JSON body describing the outcome of the webhook delivery. `applicant_id` and `status` are always required; `error_message` is additionally required whenever `status` is `false`.\n\n**Fields**\n- `applicant_id` (integer, required): the application form ID the webhook was delivered for. This is the application ID, not the candidate's applicant ID.\n- `status` (boolean, required): `true` if you processed the webhook successfully, `false` if it failed.\n- `error_message` (string): why processing failed. Required and must be non-blank when `status` is `false`; ignored when `status` is `true`.\n- `link` (string): a URL to a resource produced while processing the webhook, such as a completed background check report.\n\n**Example — reporting success**\n```json\n{\n  \"applicant_id\": 265733753,\n  \"status\": true,\n  \"link\": \"https://vendor.example.com/reports/abc123\"\n}\n```\n\n**Example — reporting a failure**\n```json\n{\n  \"applicant_id\": 265733753,\n  \"status\": false,\n  \"error_message\": \"Candidate record could not be matched in our system\"\n}\n```"
        }
      },
      {
        "location": {
          "method": "POST",
          "name": "_authorization",
          "path": "/webhook/status/{webhook_id}",
          "type": "REQUEST_HEADER"
        },
        "properties": {
          "description": "**Deprecated: `Authorization`-header authentication is being sunset** in favor of `x-api-key` authentication, which is now the standard way to authenticate with the Partner API. New integrations should use `x-api-key` instead — watch for a follow-up communication with removal timelines. The bearer token provided by the `/easy-apply` and/or `/v1/users/login` endpoints (depending on the use case). This token should be passed in the 'Authorization' header in the following format: 'Bearer <token>'.\n\nOn this endpoint that header is named `_authorization` rather than `Authorization`. You do not need to send it: authenticating with the `x-api-key` header alone is sufficient, and the bearer token is derived from your API key."
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/webhook/status/{webhook_id}",
          "statusCode": "200",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "The status was recorded. The response body carries a `developerMessage` of `status updated successfully` and a `status` field echoing the HTTP status code. Note that the `status` field in the response is the integer HTTP status code, and is unrelated to the boolean `status` field in the request body."
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/webhook/status/{webhook_id}",
          "statusCode": "400",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "The request could not be processed. The `developer_message` field explains why. This status covers:\n- `applicant_id` or `status` missing, or of the wrong type.\n- `status` sent as `false` with no `error_message`, or a blank one.\n- No successful delivery of the webhook identified by `webhook_id` was found for the given `applicant_id`. This case returns `webhook event not found` and is a `400`, not a `404`.\n- A malformed JSON body, or a `Content-Type` other than `application/json`."
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/webhook/status/{webhook_id}",
          "statusCode": "403",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "The request was rejected before it could be processed. This status is returned with one of two different bodies, depending on where the rejection happened, which is why no single schema is declared for it:\n- A missing or unrecognized `x-api-key` header is rejected by the API gateway itself, which returns `{\"message\": \"Forbidden\"}`.\n- A recognized key that lacks permission for this endpoint, or an expired bearer token, is rejected further in and returns `{\"developer_message\": ...}` naming the check that failed."
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/webhook/status/{webhook_id}",
          "statusCode": "404",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "The `webhook_id` in the path was not an integer. Note that a well-formed `webhook_id` with no matching webhook delivery returns a `400`, not a `404` — this status only indicates a malformed path."
        }
      },
      {
        "location": {
          "method": "POST",
          "path": "/webhook/status/{webhook_id}",
          "statusCode": "500",
          "type": "RESPONSE"
        },
        "properties": {
          "description": "The status could not be recorded because of an error on Apploi's side. The request may be retried, but if the original call was applied before the error reached you, the retry records a second entry."
        }
      },
      {
        "location": {
          "path": "/jobs/ai_chat/subscription",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "Endpoint for updating job ai chat feature for a specific team."
        }
      },
      {
        "location": {
          "path": "/jobs/job_attributes",
          "type": "RESOURCE"
        },
        "properties": {
          "description": "Endpoint for creating or updating job attributes for a specific team."
        }
      }
    ],
    "version": "1.3.27"
  },
  "x-amazon-apigateway-gateway-responses": {
    "INTEGRATION_TIMEOUT": {
      "responseTemplates": {
        "application/json": "#if($context.resourcePath == \"/applicants\" && $context.httpMethod == \"GET\"){\"message\": \"Request timed out. The maximum page size is 80; try a smaller limit and use offset to page through results.\"}#else{\"message\":$context.error.messageString}#end"
      }
    }
  },
  "x-amazon-apigateway-request-validators": {
    "BodyValidator": {
      "validateRequestBody": true,
      "validateRequestParameters": false
    },
    "FullRequestValidator": {
      "validateRequestBody": true,
      "validateRequestParameters": true
    }
  }
}
````