> ## Documentation Index
> Fetch the complete documentation index at: https://docs.axle.insure/llms.txt
> Use this file to discover all available pages before exploring further.
# Policy Validation
> Evaluate a set of Rules against a policy to determine if your application's requirements are met.
## 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](/api-reference/policies/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](/guides/validate/policy-validation#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](/api-reference/validation/templates/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 two 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.
```json Overall Status: Pass theme={null}
{
"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": {...}
}
}
}
```
```json Overall Status: Fail theme={null}
{
"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": {...}
}
}
}
```
## Supported Rules
The Axle team is actively working on adding additional supported Rules. Please
reach out with any suggestions!
### `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 |
```typescript Example Rule theme={null}
"policy-active": {
"status": "pass",
"metadata": {
"isActive": true
}
}
```
### `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.
1. Their policy includes collision coverage and personal collision coverage extends to a rental vehicle.
2. 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.
3. 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. |
```typescript Example Rule theme={null}
"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
```
### `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.
```typescript theme={null}
{
"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.
```typescript theme={null}
"expiration-date-comparison": {
"status": "pass",
"metadata": {
"policyExpirationDate": "2025-02-01",
"input": {
"date": "2025-01-01"
}
}
}
```
### `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 Criteria**
The 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`.
1. `collision-exists`: Determines if collision coverage is present on the policy for any vehicle or, if a `vin` is provided, for a specified vehicle.
2. `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 Usage**
This 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.
```typescript Example Rule Request theme={null}
{
rule: "collision-coverage-meets-requirements",
input: {
vin: "5FNRL38209B014050",
deductible: 1000
}
}
```
```typescript Example Rule Response theme={null}
"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`
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 Criteria**
The 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`.
1. `comprehensive-exists`: Determines if comprehensive coverage is present on the policy for any vehicle or, if a `vin` is provided, for a specified vehicle.
2. `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 Usage**
This 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.
```typescript Example Rule Request theme={null}
{
rule: "comprehensive-coverage-meets-requirements",
input: {
vin: "5FNRL38209B014050",
deductible: 1000
}
}
```
```typescript Example Rule Response theme={null}
"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`
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 Criteria**
The 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.
1. `bodily-injury-exists`: Determines if bodily injury coverage is present on the policy.
2. `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`.
3. `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 Usage**
This 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.
```typescript Example Rule Request theme={null}
{
rule: "bodily-injury-coverage-meets-requirements",
input: {
limitPerPerson: 200000
}
}
```
```typescript Example Rule Response theme={null}
"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-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 Criteria**
The 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.
1. `uninsured-underinsured-bi-exists`: Determines if UM, UIM, or UUIM motorists bodily injury coverage is present on the policy.
2. `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`.
3. `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 Usage**
This 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.
```typescript Example Rule Request theme={null}
{
rule: "uninsured-underinsured-bi-coverage-meets-requirements",
input: {
limitPerPerson: 200000
}
}
```
```typescript Example Rule Response theme={null}
"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`
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 Criteria**
The 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.
1. `property-damage-exists`: Determines if property damage coverage is present on the policy.
2. `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 Usage**
This example Rule validates that the policy has property damage coverage and that the coverage's `limitPerAccident` is greater than or equal to \$50,000.
```typescript Example Rule Request theme={null}
{
rule: "property-damage-coverage-meets-requirements",
input: {
limitPerAccident: 50000
}
}
```
```typescript Example Rule Response theme={null}
"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-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 Criteria**
The 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.
1. `uninsured-underinsured-pd-exists`: Determines if UM, UIM, or UUIM motorist property damage coverage is present on the policy.
2. `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 Usage**
This 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.
```typescript Example Rule Request theme={null}
{
rule: "uninsured-underinsured-pd-coverage-meets-requirements",
input: {
limitPerAccident: 50000
}
}
```
```typescript Example Rule Response theme={null}
"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`
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"`
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**
```typescript Example Rule Request theme={null}
{
"rule": "insureds-match",
"input": {
"insuredNames": ["John Tracy Smith", "Alex Jacob Smith", "Jane Doe"]
}
}
```
```typescript Example Rule Response theme={null}
"insureds-match": {
"status": "fail",
"metadata": {
"pass": ["John Tracy Smith", "Alex Jacob Smith"],
"fail": ["Jane Doe"],
"caution": [],
"unknown": [],
}
}
```
### `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**
```typescript Example Rule Request theme={null}
{
"rule": "address-match",
"input": {
"address": "123 Axle St. NE, Apartment 111, Atlanta, GA 30303"
}
}
```
```typescript Example Rule Response theme={null}
"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`
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 "\ \". For example, you can provide "2009 Honda Odyssey"
**Example Usage**
```typescript Example Rule Request theme={null}
{
"rule": "properties-match",
"input": {
"yearMakeModel": "2009 Honda Odyssey"
}
}
```
```typescript Example Rule Response theme={null}
"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**
```typescript Example Rule Request theme={null}
{
"rule": "properties-match",
"input": {
"vin": "AAABC38A450011111"
}
}
```
```typescript Example Rule Response theme={null}
"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**
```typescript Example Rule Request theme={null}
{
"rule": "properties-match",
"input": {
"address": "123 Axle St. NE, Apartment 111, Atlanta, GA 30303"
}
}
```
```typescript Example Rule Response theme={null}
"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-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
```typescript Example Rule Request theme={null}
{
"rule": "third-party-match",
"input": {
"name": "Major Bank",
"address": "123 Main St, Springfield, IL 62701",
}
}
```
```typescript Example Rule Response theme={null}
{
"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`
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:
1. `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.
2. `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`.
```typescript Example Rule Request theme={null}
// 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
}
}
]
}
}
}
```
```typescript Example Rule Response theme={null}
"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`
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
```typescript Example Rule Request theme={null}
{
"rule": "vehicle-use-meets-requirements",
"input": {
"use": "business",
"vin": "5FNRL38209B014050",
}
}
```
```typescript Example Rule Response theme={null}
"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`
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**
```typescript Example Rule Request theme={null}
{
"rule": "policy-created-via-credit-card"
}
```
```typescript Example Rule Response theme={null}
"policy-created-via-credit-card": {
"status": "pass",
}
```
### `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
```typescript Example Rule Request theme={null}
{
"rule": "refreshed-within-days",
"input": { "days": 30 }
}
```
```typescript Example Rule Response theme={null}
"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](/guides/completion-types) 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](/guides/completion-types#result-outcomes) to see the difference between link vs. manual (in addition to different types of manual configurations)