Policy Validation

Overview

When embedding insurance verification into your application, you may want to evaluate whether a shared insurance policy meets your business’ requirements. Each supported Rule is an individual check evaluated against the Policy object to determine if the Policy meets a certain requirement or set of requirements. For example, the policy-active Rule checks if the policy is currently active, evaluating to pass if the isActive field of the policy is true and fail if it is false. If isActive is null (not provided by the insurance carrier), this Rule will resolve to unknown. Some Rules are more complex, providing additional insight not found on the Policy object. For example, the rental-covered-for-collision Rule provides guidance on whether a policy affords coverage for collision damage when an insured is driving a rental vehicle. Some Rules require additional input to be evaluated. For example, the expiration-date-comparison Rule requires an input date to compare against the policy’s expiration date. For more details on the additional inputs that a Rule may require, refer to Supported Rules. Each Rule evaluates to one of the following statuses:

Status	Description
`pass`	The policy meets all requirements of the Rule
`fail`	The policy does not meet all the requirements of the Rule
`caution`	The policy only partially meets the requirements of the Rule or the Rule returns an inconclusive outcome.
`unknown`	Not enough data was available to determine the outcome of the Rule

Requesting Evaluation Rules

You can request that a Policy be evaluated against a specified set of Rules through the Validate Policy endpoint. Each Rule you requested will be run, and you’ll receive a response with an overall status determination of either pass, fail, or caution.

pass means that the policy succeeded in passing against all of the specified Rules.
fail means that one or more specified Rules evaluated to a status of fail.
caution means that one or more specified Rules evaluated to a status of caution. In most cases, it is recommended to complete a manual review of the policy.

The response also contains three other fields:

summary - An object containing the names of all Rules on the policy and their resolved statuses.
rules - An object containing the names of each Rules and their run details.
validation - The unique identifier for the validation result of this request.

{
  "status": "pass",
  "summary": {
    "policy-active": "pass",
    "rental-covered-for-collision": "pass",
  },
  "rules": {
    "policy-active":{
      "status": "pass",
      "metadata": {...},
    },
    "rental-covered-for-collision": {
      "status": "pass",
      "breakdown": {...},
      "metadata": {...}
    }
  },
  "validation": "val_abcdef123456"
}

{
  "status": "fail",
  "summary": {
    "policy-active": "pass",
    "rental-covered-for-collision": "fail",
  },
  "rules": {
    "policy-active":{
      "status": "pass",
      "metadata": {...},
    },
    "rental-covered-for-collision": {
      "status": "fail",
      "breakdown": {...},
      "metadata": {...}
    }
  },
  "validation": "val_abcdef123456"
}

Supported Rules

The Axle team is actively working on adding additional supported Rules. Please reach out with any suggestions!

Policy is Active

`policy-active`

Evaluates whether the policy is currently active.

Status	Cause
`pass`	The policy is currently active
`fail`	The policy is not currently active
`caution`	The `isActive` field is `null`, meaning Axle could not confirm the `isActive` status with the carrier
`unknown`	The `isActive` field is `undefined`, meaning it’s a manual policy

Example Rule

"policy-active": {
  "status": "pass",
  "metadata": {
    "isActive": true
  }
}

Rental Vehicle is Covered For Collision Damage

`rental-covered-for-collision`

Evaluates the likelihood that the policy provides coverage for collision damage when an insured is driving a rental vehicle, based on the collision coverage available on the policy and the policy terms of insurance agreements similar to the one used by this policy.There are three ways that a user’s auto insurance policy may cover collision damage to a rental vehicle.

Their policy includes collision coverage and personal collision coverage extends to a rental vehicle.
Their policy is registered in a state in which policies are required to cover collision damage to a rental vehicle under property damage liability terms.
Their policy is registered in a state in which policies are required to cover collision damage to a rental vehicle under an endorsement.

If any of these are true, then the rental-covered-for-collision Rule resolves to pass.

Rental Coverage Validation AI

In order to determine if a policy meets these criteria, Axle’s Validation AI matches the auto policy to a repository of up-to-date policy agreements (also known as forms) as well as any relevant state regulations, and then synthesizes these resources into a recommendation.

The rental-covered-for-collision recommendation may not apply the following scenarios:

long term rentals (greater than 30 days)
rental of medium or heavy duty vehicles (above 10,000 lbs)
use of temporary substitute vehicles (such as replacement or loaner vehicle)
use of rental vehicle for TNC, DNC, or other auto business
rentals outside of the continental United States

The recommendation made by the Rental Coverage Validation AI should not be treated as legal advice. It is made on a “best-effort” basis.

Status	Cause
`pass`	The policy is likely to cover an insured for collision damage to their rental vehicle either because of their personal collision coverage or due to state regulations.
`fail`	The policy is unlikely to provide coverage for collision damage to a rental vehicle.
`caution`	The Rental Coverage Validation AI is not confident in its recommendation.
`unknown`	The policy cannot be matched to the required resources to make a recommendation.

This Validation also returns a message and message code, which can be used to explain to the user why the policy is or is not likely to cover collision damage to a rental vehicle.

Message Code	Evaluation Status	Message
coll-extends-to-rental	`pass`	The policy has collision coverage and the matching policy agreements indicate that collision coverage extends to rental vehicles.
pd-covers-rental-collision	`pass`	The policy is underwritten in a state in which policies are required to cover collision damage under property damage liability terms.
endorsement-covers-rental-collision	`pass`	The policy is underwritten in a state in which policies are required to cover collision damage under an endorsement.
coll-extends-to-rental-with-caution	`caution`	The policy has collision coverage, but the matching policy agreements have conflicting answers about whether collision coverage extends to rental vehicles.
coll-extends-to-rental-with-unknown	`unknown`	The policy has collision coverage, but there is not enough information to determine if the policy extends collision coverage to rental vehicles.
coll-does-not-extend-to-rental	`fail`	The policy has collision coverage, but the matching policy agreements indicate that collision coverage does not extend to rental vehicles.
coll-not-present	`fail`	The policy does not have collision coverage, and therefore cannot extend collision coverage to rental vehicles.
coll-presence-unknown	`unknown`	It is unknown if the policy has collision coverage, and therefore it is unknown if the policy extends collision coverage to rental vehicles.

Example Rule

"rental-covered-for-collision": {
  "status": "pass",
  "message": {
    "code": "coll-extends-to-rental"
    "displayText": "The policy has collision coverage and the matching policy agreements indicate that collision coverage extends to rental vehicles."
  }
  "breakdown": {
    "collision-exists": {
      "value": "pass",
      "metadata": {
        "coverages": [
          {
            "code": "COLL",
            "label": "Collision",
            "deductible": 375,
            "property": "prp_uSdzLVpi8c76H7kl6AQ-F"
          }
        ],
        "input": {
          "coverageCode": "COLL"
        }
      }
      "collision-coverage-extends-to-rental": {
        "status": "pass",
        "metadata": {
          "carrier": "state-farm",
          "state": "NY"
        }
      },
      "property-damage-covers-rental-collision": {
        "status": "pass",
        "metadata": {
          "coverages": [
            {
              "code": "PD",
              "label": "Property Damage",
              "limitPerAccident": 50000,
              "property": "prp_uSdzLVpi8c76H7kl6AQ-F"
            }
          ],
          "state": "NY"
        }
      },
      "endorsement-covers-rental-collision": {
        "status": "pass",
        "metadata": {
          "state": "NY"
        }
      }
    }
  },
  "metadata": {
  }
}

Testing in Sandbox

All sandbox Auto policies currently support policy validation testing, but we’ve also curated a special set of test policies specifically to provide options for testing the various outcomes of the rental-covered-for-collision Rule.Enter the following credentials into an ignition session, and then select the policy labeled with the message code you would like to test. The message codes and their explanations are listed in the table above.

username: user-rental-cover
password: pass-rental-cover

Policy Expiration Date is After Provided Date

`expiration-date-comparison`

Given an input date, evaluates whether the policy’s expiration date is greater than or equal to (on or after) the input date.If no input date is provided, the rule will default to comparing the policy’s expiration date against today’s date (UTC).

Status	Cause
`pass`	The policy’s expiration date is on or after the provided input date.
`fail`	The policy’s expiration date is before the provided input date.
`unknown`	The policy’s expiration date is `null`.

This Rule optionally accepts additional input to be evaluated. If provided, the date must be an ISO 8601 string representing the date to compare against the policy’s expiration date. If omitted, the rule defaults to using today’s date.For example, valid input dates could be 2025-01-01 or 2025-01-01T00:00:00.000Z. If an invalid date is provided, this Rule will return a 400 response code.

{
  "rule": "expiration-date-comparison",
  "input": {
    "date": "2025-01-01"
  }
}

The returned evaluation will include

The policy’s expiration date.
The input date that was provided.

"expiration-date-comparison": {
  "status": "pass",
  "metadata": {
    "policyExpirationDate": "2025-02-01",
    "input": {
      "date": "2025-01-01"
    }
  }
}

Collision Coverage Meets Requirements

`collision-coverage-meets-requirements`

Evaluates whether the policy has collision coverage and if the coverage meets specific deductible requirements. This rule can evaluate coverage requirements for a specific vehicle (using VIN) or for the entire policy.Input Parameters

vin (optional): The Vehicle Identification Number to check for collision coverage specific to a vehicle.
deductible (optional): A specific collision deductible amount you want to verify against the policy.

Evaluation CriteriaThe Rule is evaluated based on the following two criteria. Both of these criteria must be true for the collision-coverage-meets-requirements Rule to resolve to pass.

collision-exists: Determines if collision coverage is present on the policy for any vehicle or, if a vin is provided, for a specified vehicle.
collision-deductible-comparison (optional): Verifies if the provided deductible is less than or equal to the deductible specified in the collision coverage of the policy. This criteria will only run if collision-exists results in a pass and the optional deductible is provided.
- If no vin is provided, the provided deductible will be verified against all collision coverages listed on the policy.
- If a vin is provided, the provided deductible will be verified against only the collision coverage listed for the specified vehicle.

Status	Cause
`pass`	The policy has collision coverage and meets all specified requirements (`deductible` and/or `vin` if provided)
`fail`	The policy either lacks collision coverage or doesn’t meet the specified deductible requirements
`unknown`	Not enough information was available to evaluate the coverage requirements

This Rule also returns a message and message code, which can be used to explain to the user why the Rule failed to result in a pass.

Message Code	Evaluation Status	Message
coll-exists	`pass`	The COLL coverage exists on this policy.
coll-exists-for-vin	`pass`	The COLL coverage exists on this policy for the specified vehicle.
coll-valid-deductible	`pass`	The COLL coverage(s) on this policy have deductible(s) less than or equal to [inputDeductible].
coll-valid-deductible-for-vin	`pass`	The COLL coverage(s) on this policy for this specified vehicle have deductible(s) less than or equal to [inputDeductible].
coll-does-not-exist	`fail`	The COLL coverage does not exist on this policy.
coll-does-not-exist-for-vin	`fail`	The COLL coverage does not exist on this policy for the specified vehicle.
coll-invalid-deductible	`fail`	The COLL coverage(s) on this policy all have deductibles greater than [inputDeductible].
coll-invalid-deductible-for-vin	`fail`	The COLL coverage(s) on this policy for this specified vehicle all have deductibles greater than [inputDeductible].
coll-unknown-deductible	`unknown`	The COLL coverage(s) on this policy have unknown deductibles.
coll-unknown-vin	`unknown`	The Axle Policy has incomplete property VIN data. Validation cannot be performed.

Example UsageThis example Rule will verify if the policy contains collision coverage for the vehicle with the given vin and that the deductible for that coverage is less than or equal to $1,000.

Example Rule Request

{
  rule: "collision-coverage-meets-requirements",
  input: {
    vin: "5FNRL38209B014050",
    deductible: 1000
  }
}

Example Rule Response

"collision-coverage-meets-requirements": {
      status: "pass",
      metadata: {
        input: {
          vin: "5FNRL38209B014050",
          deductible: 1000
        }
      },
      breakdown: {
        "collision-exists": {
          status: "pass",
          metadata: {
            coverages: [
              {
                code: "COLL",
                label: "Collision",
                deductible: 500,
                property: "prp_tmGUxLpgHjmW9r6M6WjhS",
              },
            ],
            input: {
              coverageCode: "COLL",
              vin: "5FNRL38209B014050",
            }
          },
        },
        "collision-deductible-comparison": {
          status: "pass",
          metadata: {
            coverages: [
              {
                code: "COLL",
                label: "Collision",
                deductible: 500,
                property: "prp_tmGUxLpgHjmW9r6M6WjhS",
              },
            ],
            input: { deductible: 1000, vin: "5FNRL38209B014050" },
          },
        },
      },
      message: {
        code: "coll-valid-deductible-for-vin",
        displayText:
          "The COLL coverage(s) on this policy for this specified vehicle have deductible(s) less than or equal to $1000.",
      },
    }

Comprehensive Coverage Meets Requirements

`comprehensive-coverage-meets-requirements`

Evaluates whether the policy has comprehensive coverage and if the coverage meets specific deductible requirements. This rule can evaluate coverage requirements for a specific vehicle (using VIN) or for the entire policy.Input Parameters

vin (optional): The Vehicle Identification Number to check for comprehensive coverage specific to a vehicle.
deductible (optional): A specific comprehensive deductible amount you want to verify against the policy.

Evaluation CriteriaThe Rule is evaluated based on the following two criteria. Both of these criteria must be true for the comprehensive-coverage-meets-requirements Rule to resolve to pass.

comprehensive-exists: Determines if comprehensive coverage is present on the policy for any vehicle or, if a vin is provided, for a specified vehicle.
comprehensive-deductible-comparison (optional): Verifies if the provided deductible is less than or equal to the deductible specified in the comprehensive coverage of the policy. This criteria will only run if comprehensive-exists results in a pass and the optional deductible is provided.

If no vin is provided, the provided deductible will be verified against all comprehensive coverages listed on the policy.
If a vin is provided, the provided deductible will be verified against only the comprehensive coverage listed for the specified vehicle.

Status	Cause
`pass`	The policy has comprehensive coverage and meets all specified requirements (`deductible` and/or `vin` if provided)
`fail`	The policy either lacks comprehensive coverage or doesn’t meet the specified deductible requirements
`unknown`	Not enough information was available to evaluate the coverage requirements

This Rule also returns a message and message code, which can be used to explain to the user why the Rule failed to result in a pass.

Message Code	Evaluation Status	Message
comp-exists	`pass`	The COMP coverage exists on this policy.
comp-exists-for-vin	`pass`	The COMP coverage exists on this policy for the specified vehicle.
comp-valid-deductible	`pass`	The COMP coverage(s) on this policy have deductible(s) less than or equal to [inputDeductible].
comp-valid-deductible-for-vin	`pass`	The COMP coverage(s) on this policy for this specified vehicle have deductible(s) less than or equal to [inputDeductible].
comp-does-not-exist	`fail`	The COMP coverage does not exist on this policy.
comp-does-not-exist-for-vin	`fail`	The COMP coverage does not exist on this policy for the specified vehicle.
comp-invalid-deductible	`fail`	The COMP coverage(s) on this policy all have deductibles greater than [inputDeductible].
comp-invalid-deductible-for-vin	`fail`	The COMP coverage(s) on this policy for this specified vehicle all have deductibles greater than [inputDeductible].
comp-unknown-deductible	`unknown`	The COMP coverage(s) on this policy have unknown deductibles.
comp-unknown-vin	`unknown`	The Axle Policy has incomplete property VIN data. Validation cannot be performed.

Example UsageThis example Rule will verify if the policy contains comprehensive coverage for the vehicle with the given vin and that the deductible for that coverage is less than or equal to $1,000.

Example Rule Request

{
  rule: "comprehensive-coverage-meets-requirements",
  input: {
    vin: "5FNRL38209B014050",
    deductible: 1000
  }
}

Example Rule Response

"comprehensive-coverage-meets-requirements": {
  status: "pass",
  metadata: {
    input: {
        vin: "5FNRL38209B014050",
        deductible: 1000
      }
  },
  breakdown: {
    "comprehensive-exists": {
      status: "pass",
      metadata: {
        coverages: [
          {
            code: "COMP",
            label: "Comprehensive",
            deductible: 500,
            property: "prp_tmGUxLpgHjmW9r6M6WjhS",
          },
        ],
        input: {
          coverageCode: "COMP",
          vin: "5FNRL38209B014050",
        }
      },
    },
    "comprehensive-deductible-comparison": {
      status: "pass",
      metadata: {
        coverages: [
          {
            code: "COMP",
            label: "Comprehensive",
            deductible: 500,
            property: "prp_tmGUxLpgHjmW9r6M6WjhS",
          },
        ],
        input: { deductible: 1000, vin: "5FNRL38209B014050" },
      },
    },
  },
  message: {
    code: "comp-valid-deductible-for-vin",
    displayText:
      "The COMP coverage(s) on this policy for this specified vehicle have deductible(s) less than or equal to $1000.",
  },
}

Bodily Injury Coverage Meets Requirements

`bodily-injury-coverage-meets-requirements`

Evaluates whether the policy has bodily injury coverage and if the coverage meets specific limit requirements.Input Parameters

limitPerAccident (optional): The limitPerAccident amount you want to verify against the policy.
limitPerPerson (optional): The limitPerPerson amount you want to verify against the policy.

Evaluation CriteriaThe Rule is evaluated based on the following criteria, depending on if any limit was passed in. If no limits are passed in, then the Rule is evaluated based off if bodily injury coverage exists on the policy.

bodily-injury-exists: Determines if bodily injury coverage is present on the policy.
bodily-injury-limit-per-person-comparison (if applicable): Determines if the limitPerPerson specified on the policy’s bodily injury coverage is greater than or equal to the provided limitPerPerson.
bodily-injury-limit-per-accident-comparison (if applicable): Determines if the limitPerAccident specified on the policy’s bodily injury coverage is greater than or equal to the provided limitPerAccident.

Status	Cause
`pass`	The policy has bodily injury coverage and meets all specified limit requirements
`fail`	The policy either lacks bodily injury coverage or doesn’t meet the specified limit requirements
`unknown`	Not enough information was available to evaluate the coverage requirements

This Rule also returns a message and message code which can be used to explain to the user why the Rule failed to result in a pass.

Message Code	Evaluation Status	Message
bodily-injury-exists	`pass`	The BI coverage exists on this policy.
bodily-injury-valid-limit-per-person	`pass`	The BI coverage on this policy has a `limitPerPerson` greater than or equal to [inputLimitPerPerson].
bodily-injury-valid-limit-per-accident	`pass`	The BI coverage on this policy has a `limitPerAccident` greater than or equal to [inputLimitPerAccident].
bodily-injury-valid-limits	`pass`	The BI coverage on this policy has limits greater than or equal to [inputLimitPerPerson] per person and [inputLimitPerAccident] per accident.
bodily-injury-invalid-limit-per-person	`fail`	The BI coverage on this policy has a `limitPerPerson` less than to [inputLimitPerPerson].
bodily-injury-invalid-limit-per-accident	`fail`	The BI coverage on this policy has a `limitPerAccident` less than to [inputLimitPerAccident].
bodily-injury-invalid-limits	`fail`	The BI coverage on this policy has limits less than to [inputLimitPerPerson] per person and [inputLimitPerAccident] per accident.
bodily-injury-unknown-limit-per-person	`unknown`	The BI coverage on this policy has a `limitPerPerson` that is unknown.
bodily-injury-unknown-limit-per-accident	`unknown`	The BI coverage on this policy has a `limitPerAccident` that is unknown.
bodily-injury-unknown-limits	`unknown`	The BI coverage on this policy has unknown limits.

Example UsageThis example Rule will verify if the policy has bodily injury coverage and if the limitPerPerson on the coverage is greater than or equal to $200,000.

Example Rule Request

{
  rule: "bodily-injury-coverage-meets-requirements",
  input: {
    limitPerPerson: 200000
  }
}

Example Rule Response

"bodily-injury-coverage-meets-requirements": {
  status: "pass",
  metadata: {
    input: {
      limitPerPerson: 200000,
      limitPerAccident: undefined
    }
  },
  breakdown: {
    "bodily-injury-exists": {
      status: "pass",
      metadata: {
        coverages: [
          {
            code: "BI",
            label: "Bodily Injury",
            limitPerPerson: 250000,
            limitPerAccident: 500000
          },
        ],
        input: {
          coverageCode: "BI"
        }
      }
    },
    "bodily-injury-limit-per-person-comparison": {
      status: "pass",
      metadata: {
        coverages: [
          {
            code: "BI",
            label: "Bodily Injury",
            limitPerPerson: 250000,
            limitPerAccident: 500000,
          },
        ],
        input: {
          limitPerPerson: 200000,
        },
      },
    },
  },
  message: {
    code: "bodily-injury-valid-limit-per-person",
    displayText: "The BI coverage on this policy has a limitPerPerson greater than or equal to $200000.",
  }
}

Uninsured/Underinsured Motorists Bodily Injury Coverage Meets Requirements

`uninsured-underinsured-bi-coverage-meets-requirements`

Evaluates whether a policy includes uninsured motorists (UM), underinsured motorists (UIM), or uninsured/underinsured motorists (UUIM) bodily injury coverage and verifies if the coverage(s) meet the specified limit requirements.Input Parameters

limitPerAccident (optional): The limitPerAccident amount you want to verify against the policy.
limitPerPerson (optional): The limitPerPerson amount you want to verify against the policy.

Evaluation CriteriaThe Rule is evaluated based on the following criteria. If no limits are specified in the input, then the Rule evaluates solely on the presence of any uninsured motorists, underinsured motorists, or uninsured/underinsured motorists bodily injury coverage on the policy.

uninsured-underinsured-bi-exists: Determines if UM, UIM, or UUIM motorists bodily injury coverage is present on the policy.
uninsured-underinsured-bi-limit-per-person-comparison (if applicable): Determines if the limitPerPerson on the policy’s UM, UIM, or UUIM bodily injury coverage is greater than or equal to the provided limitPerPerson.
uninsured-underinsured-bi-limit-per-accident-comparison (if applicable): Determines if the limitPerAccident on the policy’s UM, UIM, or UUIM bodily injury coverage is greater than or equal to the provided limitPerAccident.

Status	Cause
`pass`	The policy has at least one of UM, UIM, or UUIM bodily injury and meets all specified limit requirements
`fail`	The policy either doesn’t have any UM, UIM, or UUIM bodily injury coverage, or has at least one but doesn’t meet the specified limit requirements.
`unknown`	Not enough information was available to evaluate the coverage requirements.

This Rule also returns a message and message code which can be used to explain to the user why the Rule failed to result in a pass.

Message Code	Evaluation Status	Message
uninsured-underinsured-bi-exists	`pass`	At least one of UM, UIM, or UUIM bodily injury coverage exists on this policy.
uninsured-underinsured-bi-valid-limit-per-person	`pass`	At least one of UM, UIM, or UUIM bodily injury coverage on this policy has a `limitPerPerson` greater than or equal to [inputLimitPerPerson].
uninsured-underinsured-bi-valid-limit-per-accident	`pass`	At least one of UM, UIM, or UUIM bodily injury coverage on this policy has a `limitPerAccident` greater than or equal to [inputLimitPerAccident].
uninsured-underinsured-bi-valid-limits	`pass`	At least one of UM, UIM, or UUIM bodily injury coverage on this policy has limits greater than or equal to [inputLimitPerPerson] per person and [inputLimitPerAccident] per accident.
uninsured-underinsured-bi-invalid-limit-per-person	`fail`	None of UM, UIM, or UUIM bodily injury coverage on this policy has a `limitPerPerson` greater than or equal to [inputLimitPerPerson].
uninsured-underinsured-bi-invalid-limit-per-accident	`fail`	None of UM, UIM, or UUIM bodily injury coverage on this policy has a `limitPerAccident` greater than or equal to [inputLimitPerAccident].
uninsured-underinsured-bi-invalid-limits	`fail`	None of UM, UIM, or UUIM bodily injury coverage on this policy has limits greater than or equal to [inputLimitPerPerson] per person and [inputLimitPerAccident] per accident.
uninsured-underinsured-bi-unknown-limit-per-person	`unknown`	At least one of UM, UIM, or UUIM bodily injury coverage on this policy has a `limitPerPerson` that is unknown.
uninsured-underinsured-bi-unknown-limit-per-accident	`unknown`	At least one of UM, UIM, or UUIM bodily injury coverage on this policy has a `limitPerAccident` that is unknown.
uninsured-underinsured-bi-unknown-limits	`unknown`	At least one of UM, UIM, or UUIM bodily injury coverage on this policy has unknown limits.

Example UsageThis example Rule will verify if the policy has at least one of UM, UIM, or UUIM bodily injury coverage and if the limitPerPerson on the coverage is greater than or equal to $200,000.

Example Rule Request

{
  rule: "uninsured-underinsured-bi-coverage-meets-requirements",
  input: {
    limitPerPerson: 200000
  }
}

Example Rule Response

"uninsured-underinsured-bi-coverage-meets-requirements": {
  status: "pass",
  metadata: {
    input: {
      limitPerPerson: 200000,
      limitPerAccident: undefined
    }
  },
  breakdown: {
    "uninsured-underinsured-bi-exists": {
      status: "pass",
      metadata: {
        coverages: [
          {
            code: "UMBI",
            label: "Uninsured Motorists Bodily Injury",
            limitPerPerson: 250000,
            limitPerAccident: 500000
          },
        ],
        input: {
          coverageCodes: ["UMBI", "UIMBI", "UUIMBI"]
        }
      }
    },
    "uninsured-underinsured-bi-limit-per-person-comparison": {
      status: "pass",
      metadata: {
        coverages: [
          {
            code: "UMBI",
            label: "Uninsured Motorists Bodily Injury",
            limitPerPerson: 250000,
            limitPerAccident: 500000,
          },
        ],
        input: {
          limitPerPerson: 200000,
        },
      },
    },
  },
  message: {
    code: "uninsured-underinsured-bi-valid-limit-per-person",
    displayText: "At least one of UM, UIM, or UUIM bodily injury coverage on this policy has a `limitPerPerson` greater than or equal to $200000.",
  }
}

Property Damage Coverage Meets Requirements

`property-damage-coverage-meets-requirements`

Evaluates whether the policy has property damage coverage and if the coverage meets specific limit requirements.Input Parameters

limitPerAccident (optional): The limitPerAccident amount you want to verify against the policy.

Evaluation CriteriaThe Rule is evaluated based on the following criteria. If no limits are specified in the input, the Rule evaluates solely on the presence of property damage coverage on the policy.

property-damage-exists: Determines if property damage coverage is present on the policy.
property-damage-limit-per-accident-comparison (if applicable): Determines if the limitPerAccident specified on the policy’s property damage coverage is greater than or equal to the provided limitPerAccident.

Status	Cause
`pass`	The policy has property damage coverage and meets all specified limit requirements.
`fail`	The policy either lacks property damage coverage or doesn’t meet the specified limit requirements.
`unknown`	Not enough information was available to evaluate the coverage requirements.

This Rule also returns a message and message code which can be used to explain to the user why the Rule failed to result in a pass.

Message Code	Evaluation Status	Message
property-damage-exists	`pass`	The PD coverage exists on this policy.
property-damage-valid-limit-per-accident	`pass`	The PD coverage on this policy has a `limitPerAccident` greater than or equal to [inputLimitPerAccident].
property-damage-invalid-limit-per-accident	`fail`	The PD coverage on this policy has a `limitPerAccident` less than to [inputLimitPerAccident].
property-damage-unknown-limit-per-accident	`unknown`	The PD coverage on this policy has a `limitPerAccident` that is unknown.

Example UsageThis example Rule validates that the policy has property damage coverage and that the coverage’s limitPerAccident is greater than or equal to $50,000.

Example Rule Request

{
  rule: "property-damage-coverage-meets-requirements",
  input: {
    limitPerAccident: 50000
  }
}

Example Rule Response

"property-damage-coverage-meets-requirements": {
  status: "pass",
  metadata: {
    input: {
      limitPerAccident: 50000
    }
  },
  breakdown: {
    "property-damage-exists": {
      status: "pass",
      metadata: {
        coverages: [
          {
            code: "PD",
            label: "Property Damage",
            limitPerAccident: 100000,
          },
        ],
        input: {
          coverageCode: "PD"
        }
      }
    },
    "property-damage-limit-per-accident-comparison": {
      status: "pass",
      metadata: {
        coverages: [
          {
            code: "PD",
            label: "Property Damage",
            limitPerAccident: 100000,
          },
        ],
        input: {
          limitPerAccident: 50000
        }
      }
    }
  },
  message: {
    code: "property-damage-valid-limit-per-accident",
    displayText: `The PD coverage on this policy has a limitPerAccident greater than or equal to $50000.`,
  }
}

Uninsured/Underinsured Motorists Property Damage Coverage Meets Requirements

`uninsured-underinsured-pd-coverage-meets-requirements`

Evaluates whether a policy includes uninsured motorist (UM), underinsured motorist (UIM), or uninsured/underinsured motorist (UUIM) property damage coverage and verifies if the coverage(s) meet the specified limit requirements.Input Parameters

limitPerAccident (optional): The limitPerAccident amount you want to verify against the policy.

Evaluation CriteriaThe Rule is evaluated based on the following criteria. If no limit is specified in the input, the Rule evaluates solely on the presence of any uninsured motorist (UM), underinsured motorist (UIM), or uninsured/underinsured motorist (UUIM) property damage coverage on the policy.

uninsured-underinsured-pd-exists: Determines if UM, UIM, or UUIM motorist property damage coverage is present on the policy.
uninsured-underinsured-pd-limit-per-accident-comparison (if applicable): Determines if the limitPerAccident on the policy’s UM, UIM, or UUIM property damage coverage is greater than or equal to the provided limitPerAccident.

Status	Cause
`pass`	The policy has at least one of UM, UIM, or UUIM property damage coverage and meets all specified limit requirements.
`fail`	The policy either doesn’t have any UM, UIM, or UUIM property damage coverage, or has at least one but doesn’t meet the specified limit requirements.
`unknown`	Not enough information was available to evaluate the coverage requirements.

This Rule also returns a message and message code which can be used to explain to the user why the Rule failed to result in a pass.

Message Code	Evaluation Status	Message
uninsured-underinsured-pd-exists	`pass`	At least one of UM, UIM, or UUIM property damage coverage exists on this policy.
uninsured-underinsured-pd-valid-limit-per-accident	`pass`	At least one of UM, UIM, or UUIM property damage coverage on this policy has a `limitPerAccident` greater than or equal to [inputLimitPerAccident].
uninsured-underinsured-pd-invalid-limit-per-accident	`fail`	None of UM, UIM, or UUIM property damage coverage on this policy has a `limitPerAccident` less than to [inputLimitPerAccident].
uninsured-underinsured-pd-unknown-limit-per-accident	`unknown`	At least one of UM, UIM, or UUIM property damage coverage on this policy has a `limitPerAccident` that is unknown.

Example UsageThis example Rule will verify if the policy has at laest one of UM, UIM, or UUIM property damage coverage and if the limitPerAccident on the coverage is greater than or equal to $50,000.

Example Rule Request

{
  rule: "uninsured-underinsured-pd-coverage-meets-requirements",
  input: {
    limitPerAccident: 50000
  }
}

Example Rule Response

"uninsured-underinsured-pd-coverage-meets-requirements": {
  status: "pass",
  metadata: {
    input: {
      limitPerAccident: 50000
    }
  },
  breakdown: {
    "uninsured-underinsured-pd-exists": {
      status: "pass",
      metadata: {
        coverages: [
          {
            code: "UIMPD",
            label: "Underinsured Motorists Property Damage",
            limitPerAccident: 100000,
          },
        ],
        input: {
          coverageCodes: ["UMPD", "UIMPD", "UUIMPD"]
        }
      }
    },
    "uninsured-underinsured-pd-limit-per-accident-comparison": {
      status: "pass",
      metadata: {
        coverages: [
          {
            code: "UIMPD",
            label: "Underinsured Motorists Property Damage",
            limitPerAccident: 100000,
          },
        ],
        input: {
          limitPerAccident: 50000
        }
      }
    }
  },
  message: {
    code: "uninsured-underinsured-pd-valid-limit-per-accident",
    displayText: `At least one of UM, UIM, or UUIM property damage coverage on this policy has a `limitPerAccident` greater than or equal to $50000.`,
  }
}

Insureds Match

`insureds-match`

Evaluates whether all of the input insured names are listed on the Axle policy.

Status	Cause
`pass`	All of the input insured names are listed on the Axle policy.
`caution`	One or more of the input insured names passed a fuzzy match. This occurs when either the input name or Axle policy name is missing an additional first name or middle name (e.g. “John Tracy Smith” vs. “John Smith”).
`fail`	One or more of the input insured names were not listed on the Axle policy.
`unknown`	An error occurred during validation.

Input Parameters

insuredNames: An array of full names provided as strings. Each name should be provided in the format "firstName middleName lastName suffix"
fuzzyMatch (optional): A boolean that enables similarity-based matching for insured names.

If fuzzyMatch is true, this Rule calculates a similarity score between each input name and the policy insured name. A score of 0.7 or higher is treated as a match (pass), and a score below 0.7 is treated as not matching (fail).

This Rule currently does not support nickname matching. Please contact the Axle team if this is a feature of interest.Additionally, it is unlikely that insureds across households will be present on a single insurance policy. Please ensure that the input only contains insured names you expect to be on the policy.

Example Usage

Example Rule Request

{
  "rule": "insureds-match",
  "input": {
    "insuredNames": ["John Tracy Smith", "Alex Jacob Smith", "Jane Doe"],
    "fuzzyMatch": true
  }
}

Example Rule Response

"insureds-match": {
  "status": "fail",
  "metadata": {
    "pass": ["John Tracy Smith", "Alex Jacob Smith"],
    "fail": ["Jane Doe"],
    "caution": [],
    "unknown": [],
  }
}

Address Match

`address-match`

Evaluates whether input address matches the address that is listed on the Axle policy.

Status	Cause
`pass`	Input address matches Axle Policy address
`caution`	Input and Axle policy `addressLine2` do not match
`fail`	Input address does not match Axle Policy address
`unknown`	There is insufficient information to compare input address and Axle Policy address.

Input Parameters

address: Full address provided as a string that includes both Address Line 1 and 2 along with city, postal code, and state.

Example Usage

Example Rule Request

{
  "rule": "address-match",
  "input": {
    "address": "123 Axle St. NE, Apartment 111, Atlanta, GA 30303"
  }
}

Example Rule Response

"address-match": {
  "status": "pass",
  "metadata": {
    "pass": [
      {
        "addressLine1": "123 Axle Street NE",
        "addressLine2": "APT 111",
        "city": "Atlanta",
        "state": "GA",
        "postalCode": "30303",
        "country": "US"
      }
    ],
    "fail": [],
    "caution": [],
    "unknown": []
  }
}

Properties Match

`properties-match`

Evaluates whether input property matches the property that is listed on Axle Policy. Properties can be matched via yearMakeModel, VIN, or address (corresponding to type of property).

yearMakeModel (property type `vehicle`)

Evaluates if provided yearMakeModel matches yearMakeModel listed as one of the properties when policy.properties.type=vehicle

Status	Cause
`pass`	Exact match on the year and high similarity threshold score on `make` and `model` to one of the properties listed on the Axle Policy
`caution`	Exact match on the year and medium similarity threshold score on `make` and `model`
`fail`	No match on year or low similarity threshold score on `make` and `model`
`unknown`	There is insufficient information to compare input yearMakeModel and Axle Policy

Input Parameters

yearMakeModel: Provide a string in the following format “<year> <make model of the vehicle>”. For example, you can provide “2009 Honda Odyssey”

Example Usage

Example Rule Request

{
  "rule": "properties-match",
  "input": {
      "yearMakeModel": "2009 Honda Odyssey"
  }
}

Example Rule Response

"properties-match": {
    "status": "pass",
    "metadata": {
      "pass": [
        {
          "type": "vehicle",
          "data": {
            "bodyStyle": "minivan",
            "vin": "5FNRL38209B014050",
            "model": "Odyssey",
            "year": "2009",
            "make": "Honda"
          },
          "id": "prp_tmGUxLpgHjmW9r6M6WjhS"
        }
      ],
      "fail": [],
      "caution": [],
      "unknown": []
    }
}

vin (property type `vehicle`)

Evaluates if provided VIN matches the VIN listed as one of the properties when policy.properties.type=vehicle

Status	Cause
`pass`	VIN matches a property listed on the Axle Policy
`fail`	VIN doesn’t match any of the properties
`unknown`	There is insufficient information to compare input VIN and Axle Policy

Input Parameters

vin: Provide VIN number of the vehicle as a string

Example Usage

Example Rule Request

{
  "rule": "properties-match",
  "input": {
      "vin": "AAABC38A450011111"
  }
}

Example Rule Response

"properties-match": {
  "status": "pass",
  "metadata": {
    "pass": [
      {
        "type": "vehicle",
        "data": {
          "vin": "AAABC38A450011111",
          "model": "Q4",
          "year": "2025",
          "make": "Audi"
        },
        "id": "prp_8BKSFvreM7FOwI_3X2sxB"
      }
    ],
    "fail": [],
    "caution": [],
    "unknown": []
  }
}

Address (property type `dwelling`)

Evaluates if provided address matches the address listed as one of the properties when policy.properties.type=dwelling

Status	Cause
`pass`	Input address matches one of the properties on the Axle Policy
`caution`	Input address may not match any of the properties because of a difference in `addressLine2`
`fail`	Input address does not match any of the properties
`unknown`	There is insufficient information to compare input address and Axle Policy

Input Parameters

address: Full address provided as a string that includes both Address Line 1 and 2 along with city, postal code, and state.

Example Usage

Example Rule Request

{
  "rule": "properties-match",
  "input": {
    "address": "123 Axle St. NE, Apartment 111, Atlanta, GA 30303"
  }
}

Example Rule Response

"address-match": {
  "status": "pass",
  "metadata": {
    "pass": [
      {
        "addressLine1": "123 Axle Street NE",
        "addressLine2": "APT 111",
        "city": "Atlanta",
        "state": "GA",
        "postalCode": "30303",
        "country": "US"
      }
    ],
    "fail": [],
    "caution": [],
    "unknown": []
  }
}

Third Parties Match

`third-party-match`

Evaluates whether a third party listed on the policy matches the provided name and, if provided, the third party’s address.

Input Parameters

name (required): String representing the name of the third party (e.g., “Major Bank”).
address (optional): String representing the address of the third party.

Responses

Status	Cause
`pass`	Input name is a high-confidence match. If provided, address is also a high-confidence match.
`caution`	Input name is a medium-confidence match OR, if provided, address is a medium confidence match.
`fail`	Input name does not match or address does not match.
`unknown`	There is insufficient information to compare the input third party details with those on the policy

Example Usage

Example Rule Request

{
  "rule": "third-party-match",
  "input": {
    "name": "Major Bank",
    "address": "123 Main St, Springfield, IL 62701",
  }
}

Example Rule Response

{
  "third-party-match": {
    "status": "pass",
    "metadata": {
      "pass": [
        {
          "id": "prp_abc123",
          "type": "interest",
          "data": {
            "name": "Major Bank",
            "address": {
              addressLine1: "123 Main St",
              addressLine2: null,
              state: "IL",
              city: "Springfield",
              country: "USA",
              postalCode: "62701",
            }
          }
        }
      ],
      "fail": [],
      "caution": [],
      "unknown": []
    }
  }
}

Required Policy Information is Present

`required-policy-information-is-present`

Evaluates if the policy either has (1) certain required fields present OR (2) at least one declarations page. If either sub-rule passes, the overall Rule resolves to pass. Otherwise, it resolves to fail.This Rule combines two separate sub-rules:

fields-exist – Verifies that all fields specified by your requiredFields input are present on the policy. If every requested field is found, this Rule resolves to pass; otherwise, it resolves to fail and includes a missingFields list in the metadata.
declarations-page-exists – Checks whether the policy has at least one document classified by Axle as a declaration page.

Status	Cause
`pass`	The policy has all required fields, or there is a declarations page (or both).
`fail`	Neither the required fields nor a declarations page could be confirmed on the policy.

Input Parameters

requiredFields: An object used to specify which fields must exist on the policy. Each key maps to a boolean (or nested object / array structure) indicating whether that particular field is required. The shape of the object mirrors the Axle Policy Schema.

Below is an example request specifying all the possible required fields that can be checked for existence. If you receive a 400 Input Validation error, please check that you provided only fields listed in the example below.If either the required fields or the declarations page check is satisfied, the Rule evaluates to pass.

Example Rule Request

// The below example shows all the possible fields that can be checked for existence
{
"rule": "required-policy-information-is-present",
"input": {
   "requiredFields": {
      "carrier": true,
      "type": true,
      "policyNumber": true,
      "premium": true,
      "isActive": true,
      "effectiveDate": true,
      "expirationDate": true,
      "address": {
        "addressLine1": true,
        "state": true,
        "city": true,
        "postalCode": true
      }
      "properties": [
        {
          "data": {
            "vin": true,
            "year": true,
            "make": true,
            "model": true,
            "use": true
          }
        }
      ],
      "coverages":[
        {
          "deductible": true,
          "limitPerPerson": true,
          "limitPerAccident": true
        }
      ],
      "insureds":[
        {
          "firstName": true,
          "lastName": true
        }
      ],
      "thirdParties":[
        {
          "name": true,
          "address": {
            "addressLine1": true,
            "state": true,
            "city": true,
            "postalCode": true
          }
        }
      ]
  }
}
}

Example Rule Response

"required-policy-information-is-present": {
  "status": "pass",
  "summary": {
      "required-policy-information-is-present": "pass"
  },
  "rules": {
      "required-policy-information-is-present": {
          "status": "pass",
          "breakdown": {
              "fields-exist": {
                  "status": "fail",
                  "metadata": {
                      "missingFields": ["premium"]
                  }
              },
              "declarations-page-exists": {
                  "status": "pass",
                  "metadata": {
                      "documents": [
                          {
                              "createdAt": "2025-01-10T16:28:07.089Z",
                              "issuedDate": "2024-12-24T00:00:00.000Z",
                              "name": "Auto Policy Document Amended",
                              "source": "carrier",
                              "type": [
                                  "policy-agreement",
                                  "declaration-page"
                              ],
                              "key": "doc_FqDyv9F2b6x5eZ_jokGWU.pdf",
                              "effectiveDate": null
                          }
                      ]
                  }
              }
          },
          "metadata": {}
      }
  }
}

Vehicle Use Meets Requirements

`vehicle-use-meets-requirements`

Evaluates whether any vehicle on the policy has a specified use (e.g., business, commute, or pleasure). If a vin or yearMakeModel is provided, the rule ensures that the matched vehicle has the expected use.

Input Parameters

use (required): One of business, commute, or pleasure.
vin (optional): The Vehicle Identification Number of the vehicle you want to check. If provided, the rule will only evaluate the vehicle with this VIN.
yearMakeModel (optional): Formatted string, e.g., "2020 Toyota Camry" specifying which vehicle to check. If provided, the rule will only evaluate the vehicle that matches this yearMakeModel.

Responses

Status	Cause
`pass`	At least one vehicle (or the specified vehicle) has the expected use.
`fail`	All vehicles (or just the specified vehicle) fail to meet the usage requirement.
`unknown`	Vehicle use data is not available or the specified vehicle is not found on the policy.

Example Usage

Example Rule Request

{
"rule": "vehicle-use-meets-requirements",
"input": {
  "use": "business",
  "vin": "5FNRL38209B014050",
}
}

Example Rule Response

"vehicle-use-meets-requirements": {
"status": "pass",
"metadata": {
  "pass": [
    {
      "id": "prp_tmGUxLpgHjmW9r6M6WjhS",
      "type": "vehicle",
      "data": {
        "vin": "5FNRL38209B014050",
        "make": "Honda",
        "year": "2019",
        "model": "Odyssey",
        "use": "business"
      }
    }
  ],
  "fail": [],
  "caution": [],
  "unknown": []
}
}

Policy Created Via Credit Card Form

`policy-created-via-credit-card`

Evaluates whether the policy was created via Axle’s credit card submission flow.This Rule does not require any input.

Status	Cause
`pass`	The policy is a credit card policy
`fail`	The policy is not a credit card policy

Example Usage

Example Rule Request

{
  "rule": "policy-created-via-credit-card"
}

Example Rule Response

"policy-created-via-credit-card": {
  "status": "pass",
}

Policy Refreshed Within Days

`refreshed-within-days`

Evaluates whether the policy has been refreshed within the last N days (relative to the current time the validation is executed).

Input Parameters

days (required): A non‑negative number representing how many days back from “now” to consider acceptable. If the policy’s refreshedAt timestamp is on or after the computed threshold (more recent than days days ago), the Rule resolves to pass; otherwise it resolves to fail.

Responses

Status	Cause
`pass`	`policy.refreshedAt` is within (>=) the last `days` days.
`fail`	`policy.refreshedAt` is older than the last `days` days.

This Rule does not currently return caution or unknown outcomes.

Metadata Returned

refreshedAt: The policy’s refreshedAt timestamp.
input.days: The input number of days used for comparison.
thresholdDate: The ISO timestamp representing the earliest acceptable refresh time (now - days).

Example Usage

Example Rule Request

{
  "rule": "refreshed-within-days",
  "input": { "days": 30 }
}

Example Rule Response

"refreshed-within-days": {
  "status": "pass",
  "metadata": {
    "refreshedAt": "2025-08-15T14:22:10.123Z",
    "input": { "days": 30 },
    "thresholdDate": "2025-08-10T14:22:10.456Z"
  }
}

Applicability of Evaluation Rules

Depending on the completion result of Axle ignition, not all Rules are applicable. For example, when manual is enabled and end-users decide to use Policy Form as their verification method, they enter only basic policy details through a short form. Since no coverage information is collected, attempting to validate missing data does not apply.

Configuration of completion results (i.e. manual vs. link) are set up during onboarding. You can modify the accepted completion results and manual configuration options by contacting the Axle team.

Due to insufficient information to validate the policy or compare provided values, the status of those rules will be marked as unknown. For the most comprehensive validation results, it is recommended to encourage your application’s users to complete via link or by uploading a full policy document such as declaration page. For more information on result outcomes, please consult Result Outcomes to see the difference between link vs. manual (in addition to different types of manual configurations)

​Overview

​Requesting Evaluation Rules

​Supported Rules

​policy-active

​rental-covered-for-collision

​Rental Coverage Validation AI

​Testing in Sandbox

​expiration-date-comparison

​collision-coverage-meets-requirements

​comprehensive-coverage-meets-requirements

​bodily-injury-coverage-meets-requirements

​uninsured-underinsured-bi-coverage-meets-requirements

​property-damage-coverage-meets-requirements

​uninsured-underinsured-pd-coverage-meets-requirements

​insureds-match

​address-match

​properties-match

​yearMakeModel (property type vehicle)

​vin (property type vehicle)

​Address (property type dwelling)

​third-party-match

​Input Parameters

​Responses

​Example Usage

​required-policy-information-is-present

​vehicle-use-meets-requirements

​Input Parameters

​Responses

​Example Usage

​policy-created-via-credit-card

​refreshed-within-days

​Input Parameters

​Responses

​Metadata Returned

​Example Usage

​Applicability of Evaluation Rules

Overview

Requesting Evaluation Rules

Supported Rules

`policy-active`

`rental-covered-for-collision`

Rental Coverage Validation AI

Testing in Sandbox

`expiration-date-comparison`

`collision-coverage-meets-requirements`

`comprehensive-coverage-meets-requirements`

`bodily-injury-coverage-meets-requirements`

`uninsured-underinsured-bi-coverage-meets-requirements`

`property-damage-coverage-meets-requirements`

`uninsured-underinsured-pd-coverage-meets-requirements`

`insureds-match`

`address-match`

`properties-match`

yearMakeModel (property type `vehicle`)

vin (property type `vehicle`)

Address (property type `dwelling`)

`third-party-match`

Input Parameters

Responses

Example Usage

`required-policy-information-is-present`

`vehicle-use-meets-requirements`

Input Parameters

Responses

Example Usage

`policy-created-via-credit-card`

`refreshed-within-days`

Input Parameters

Responses

Metadata Returned

Example Usage

Applicability of Evaluation Rules