Topics on this page

Configure LexisNexis C.L.U.E. in BriteSuite

LexisNexis Comprehensive Loss Underwriting Exchange (C.L.U.E) is an automobile claims history information exchange that enables insurance companies to access prior claim information from the C.L.U.E. personal automobile claims repository. 

These claims contain information such as dollar amounts of losses by claim type, age of loss, carrier, policyholder, and vehicle identification. C.L.U.E. information is based on claims information that has been provided to LexisNexis Risk Solutions Inc. or its predecessor entity by participating insurance carriers.

LexisNexis C.L.U.E. offers several benefits:

  • Saves time during application intake. Auto clients can validate loss history for potential customers.
  • Makes risk assessment much easier and more accurate.  
  • Increases data management efficiency.

The LexisNexis C.L.U.E. integration consists of two parts:

  • Contributing claim data 
  • Ordering reports

Note: To order reports, you must contribute to LexisNexis’s C.L.U.E. database.

Implement LexisNexis C.L.U.E.

You have two options to implement LexisNexis C.L.U.E.:

  • Use BriteCore’s LexisNexis C.L.U.E. plugin to provide claims history information. If you choose to use our pre-written plugin, all you need to do is map your data (Steps 2 and 3.) 

Note: Our team provides data mapping as an additional service.

  • You can write your own plugin using custom logic.

Note: At this point, plugins are available only in the quote flow for auto policy.

To learn more about plugins, please refer to BriteCore’s plugins documentation.

This tutorial walks you through implementing LexisNexis C.L.U.E.in BriteCore if you want to write your own plugin. It also helps you understand how LexisNexis C.L.U.E.integrates with BriteSuite.

LexisNexis C.L.U.E. functionality

This section provides an overview of how LexisNexis C.L.U.E. works in BriteQuote. 

Note: You can’t download a PDF option for the claims history results. C.L.U.E. data is available only via XML per the LexisNexis integration at this time.

Review screen (request data)

The Loss History button is located on the Review screen of the quote flow. The basic requirements for C.L.U.E.:

  • Subject full name
  • Current address 

However, for best matching results, we recommend you input as much subject information as possible, including, but not limited to:

  • Driver’s license number.
  • Date of birth.
  • Prior policy number.

This information is collected on the Drivers screen and will be sent when the agent selects Get Loss History

Note: This integration doesn’t run automatically. The agent must initiate the Loss History request by selecting the Get Loss History button. 

Drivers screen (response data)

If data is returned from LexisNexis, associated violations will be added to the respective driver’s screen.

C.L.U.E. runs for all drivers on the quote, and the following Accident and Violation fields are filled out: 

  • Date
  • Type
  • Total Damages 

Note: The violations returned from C.L.U.E. can be mapped to the accidents and violations listed in the Lines Configuration.

Alert messages

LexisNexis may return the following alert messages in the results:

  • Security freeze
  • Fraud alert 
  • Identify theft
  • Legal hold (associated with a data dispute flag)

Error handling

BriteCore displays error messages directly from LexisNexis. These error messages include, but aren’t limited to: 

  • Missing mandatory fields for report ordering.
  • Connection errors.
  • Configuration errors.

Set up LexisNexis C.L.U.E. in BriteSuite

To set up LexisNexis C.L.U.E. in BriteSuite, you need to do the following:

Step 1: Contact LexisNexis

Contact LexisNexis to complete the paperwork and set up an account. LexisNexis will provide the:

  • Client ID.
  • PNC account number.
  • Carrier account ID.
  • Carrier account number.
  • Rule plan ID.

Step 2: Contact your BriteCore support team

Provide your LexisNexis information to the BriteCore support team. The BriteCore staff will set up the configuration in BriteDeploy and provide you with the URL to the service’s HTTP endpoint.

Step 3: Consider your configuration options

Consider your configuration options and fill out the LexisNexis C.L.U.E. configuration questionnaire and the violations template (within the questionnaire.) 

Step 4: Create the data mapping

Map the data from LexisNexis to your lines configuration. In this step, you will take your specific user-defined fields from lines and map them to the data you receive from LexisNexis C.L.U.E. (and back).

 To learn more about how data mapping works in BriteCore, please refer to our data mapping documentation. Sample data for a POST/mappings request.

View code
Full request data
    {
        "data": {
            "type": "mapping",
            "attributes": {
                "from": "quote",
                "to": "lexisnexis-clue",
                "mapping": {
                    "template": """\
[
    {%- set policy_field_answers = source.rootRiskQuote.risk_state.field_answers %}
    {%- set driver_risk_type = source.riskTypes|selectattr("name", "equalto", "drivers")|first %}
    {%- set risk_quotes = source.rootRiskQuote.risk_quotes %}
    {%- set driver_risk_quotes = [] %}
    {%- for risk_quote in risk_quotes if risk_quote.risk_state.type.id == driver_risk_type.id %}
    {{ driver_risk_quotes.append(risk_quote) or  ""}}
    {% endfor %}
    {%- for driver_risk_quote in driver_risk_quotes %}
    {
        {%- set field_answers = driver_risk_quote.risk_state.field_answers %}
        "address": {
            "house": " ",
            "street" : "{{ policy_field_answers.streetAddressNI }}",
            "city" : "{{ policy_field_answers.cityNI }}",
            "state" : "{{ policy_field_answers.stateOfNI[12:] }}",
            "postal_code" : {{ policy_field_answers.zipCodeNI|int }}
        },
        "drivers_license": {
            {% if field_answers.licenseNumber is defined and field_answers.licenseNumber != None %}
            "number": "{{ field_answers.licenseNumber }}",
            {% endif %}
            {% if field_answers.licenseState in (None, "") %}
            "state": "ZZ",
            {% else %}
            "state": "{{ field_answers.licenseState.split('_')[1][:2].upper() if '_' in field_answers.licenseState else field_answers.licenseState }}",
            {% endif %}
        },
        "policy": {
            "number": "{{ policy_field_answers.otherPolicyNumberId }}"
        },
        "subject": {
            "first_name": "{{ field_answers.firstName }}",
            "last_name": "{{ field_answers.lastName }}",
            "date_of_birth": "{{ field_answers.dateOfBirth }}",
            "ssn": "{{ field_answers.socialSecurityNumber }}"
        }
    }{% if loop.nextitem is defined %},{% endif %}
    {% endfor %}
]"""
                },
            },
        }
    },
    {
        "data": {
            "type": "mapping",
            "attributes": {
                "from": "lexisnexis-clue",
                "to": "quote",
                "mapping": {
                    "template": """\
{% set map_violation_type =  {
        "Collision": "violationType_accidentatfaultdescribeincommentsincludingdateofaccidentdateofconvictiona",
        "Comprehensive": "violationType_comprehensiveLossAnimalGlassOther",
        "Glass": "violationType_comprehensiveLossAnimalGlassOther",
        "Towing and Labor": "violationType_towingLoss"
    }
%}
{
    "claims": [
        {% for report in source.reports if report.claims%}
            {% for claim in report.claims %}
                {
                    "mapped": {
                        "violationDate": "{{ claim.date }}",
                        "violationBodilyInjury": {{false}},
                        "violationInformation": "",
                        "violationType": {{'"' ~ map_violation_type[claim.payments[0].type] ~ '"' if map_violation_type[claim.payments[0].type] else none}},
                        "violationTotalDamages": "{{claim.payments|map(attribute='amount')|map('float')|sum|round(2)}}",
                    },
                    "policyHolderFirstName": "{{claim.policy_holder.first_name}}",
                    "policyHolderMiddleName": "{{claim.policy_holder.middle_name}}",
                    "policyHolderLastName": "{{claim.policy_holder.last_name}}"
                }{% if loop.nextitem is defined %},{% endif %}
            {% endfor %}{% if loop.nextitem is defined %},{% endif %}
        {% endfor %}
    ]
}"""
                },
            },
        }
    },

Step 5: Write the plugin

If you’re using BriteCore’s LexisNexis C.L.U.E.  plugin, skip this step.

To write your own plugin, interface with LexisNexis C.L.U.E. at:

View code
POST <integrations url>/lexisnexis/clue-auto/

Add this following script to the header of your HTML file:

View code
<script src="https://unpkg.com/@britecore/ui-plugins-client"> </script>

You can now use the BriteCorePlugin helper so your plugin can communicate with BriteCore:

View code
import {
  fetchCLUEReport,
  visible,
  enabled,
  plugin
} from './lib.js'

plugin.initialize({
  "button-row": {
    buttons: [{
      text: "LexisNexis CLUE Auto",
      callback: fetchCLUEReport,
      visible: visible,
      enabled: enabled,
    }, ],
  },
});

Sample response from LexisNexis C.L.U.E.

View code
data: {
    reports: [{
      alerts: [{
          type: 'test type 1',
          message: 'test message 1'
        },
        {
          type: 'test type 2',
          message: 'test message 2'
        },
        {
          type: 'test type 3',
        }
      ],
      claims: [{
        payments: [{
            amount: 99.99,
            type: "Collision"
          },
          {
            amount: 0.01,
            type: "Collision"
          }
        ],
        date: '2020-01-01',
        policy_holder: {
          first_name: fieldAnswers.firstName.toUpperCase(),
          last_name: fieldAnswers.lastName.toUpperCase()
        },
        consumer_narrative: {
          date_filed: '2020-01-01',
          message: 'test message'
        }
      }]
    }]
  }
}

Step 6: Host your plugin in a public location

If you’re using BriteCore’s LexisNexis C.L.U.E. plugin, BriteCore hosts the plugin for you. 

Otherwise, each plugin is a HTML document rendered in a hidden iframe. BriteCore’s UI queries the plugins available and renders any plugin on the specified pages.

Since BriteCore’s UI runs in a browser, the request for the plugin must occur without credentials to a publicly available location, or BriteCore must host the plugin placing the HTML file behind our authentication.

Step 7: Register the plugin in BriteIntegrations

If you’re using BriteCore’s LexisNexis C.L.U.E. plugin, BriteCore registers the plugin for you. Otherwise, you can register your plugin using our Plugin Manager web UI.