Response Filtering
Use query string parameters to view exposure data.
Overview
Platform APIs support the filtering of HTTP responses in selected operations using query strings that may be appended to the endpoint of an HTTP request. These GET operations are typically known as search operations and include the term search in their name (e.g. Search Accounts, Search Locations).
A filter consists of a single expression that defines an property, a condition (a property value), and an operator (e.g. = or LIKE). The filter keyword supports four filtering operations: comparison operations, logical operations, list operations and matching operations.
Multiple expressions may be linked together using logical operators. A complex query links together two or more expressions using one or more logical operators (AND or OR)
Query strings
A query string consists of one or more query parameters that defines an expression. These query parameters enable you to filter, sort, and paginate the data returned in an HTTP response. Where the endpoint defines the path to a resource, the query string controls the scope or order of the records returned from that resource.
For example, the following CURL request defines a query string that selects accounts matching the specified filter parameter criteria and paginates the records returned in the response based on the specified sort and limit parameters. Account records that do not match the specified criteria are not returned.
curl --request GET \
--url 'https://{host}/platform/riskdata/v1/exposures/56/accounts? \
filter=locationsCount%3E%3D200 \
&sort=accountName%2CcedantName%2CownerName%20ASC \
&limit=50 \
&allowDeepFilters=false' \
--header 'accept: application/json'
The query string is appended to the endpoint using the ? character. Each query parameter is identified by a keyword (filter, sort, limit, allowDeepFilters). Each subsequent query parameter within the query string is introduced with an ampersand (&).
This document describes filter query parameter in detail.
Operators
A query string may include a single filter query parameter.
This parameter may define a simple query consisting of a single expression or a complex query that evaluates multiple expressions. The filter query parameter supports the following operators: comparison operators, list operators, and logical operators.
- Comparison operators define expressions that filter the records returned by a response based on the evaluation of a property value.
- List operators define expressions that filter the records returned by a response based on a range of property values.
- Logical operators enable concatenating multiple expressions together into complex queries that filter responses based on the values of multiple properties.
Comparison operators
A comparison operator is a keyword that defines a relationship between a property and a property value in a query parameter.
The property, comparison operator, and property value define an expression. The API evaluates this expression and returns all of the records that match the specified criteria.
Different comparison operators may be used depending on the data type of the property evaluated. Resource properties are generally defined as one of three data types: String, Number, and Boolean, with dates representing a sort of pseudo-data type, which we have identified a YYYY-MM-DD. Although date property values are Strings, these values are treated as if were Numbers in query strings.)
Platform APIs support the following comparison operators: =, !=, >, <, >=, <=, LIKE, and NOT LIKE.
| Comparison Operator | Data Types | Description |
|---|---|---|
= | String, Number, Boolean, YYYY-MM-DD | Selects records with property values that exactly match a specified property value. |
!= | String, Number, Boolean, YYYY-MM-DD | Selects records with property values that do not match the specified property value. |
> | Number, YYYY-MM-DD | Selects records with property values that are greater than the specified property value. This operator may be used to evaluate numeric values only. |
< | Number, YYYY-MM-DD | Selects records with property values that are less than the specified property value. |
>= | Number, YYYY-MM-DD | Selects records with property values that are greater than or equal to the specified property value. |
<= | Number, YYYY-MM-DD | Selects records with property values that are less than or equal to the specified property value. |
LIKE | String | Selects records with property values that match the specified string pattern. The asterisk character (*) may be used as a wildcard character to represent zero or more characters. |
NOT LIKE | String | Selects records with property values that do not match the specified string pattern. The asterisk character (*) may be used as a wildcard character to represent zero or more characters. |
The following query string defines a simple expression that uses the = comparison operator.
curl --request GET \
--url 'https://{host}/platform/riskdata/v1/exposures/56/accounts? \
filter=locationsCount = 200'
List operators
A list operator is a keyword that defines a relationship between a property and multiple property values.
The property, list operator, and comma-separated list property values define an expression. The API evaluates this expression and returns all of the records that match the specified criteria.
| Operator | Data Type | Description |
|---|---|---|
IN | String, Number | Selects records with property values that match a property value specified in a list of property values. |
NOT IN | String, Number | Selects records with property values that do not match a property value specified in a list of property values. |
The following query defines a simple query using a list operator:
curl --request GET \
--url = 'https://path/data-store/referencedata/v1/tagGroups? \
filter=tagGroupId IN (4,15)'
Note that the comma-separated list of property values are enclosed in parentheses.
The Platform API does not support filtering by YYYY-MM-DD properties using list operators. If you want to search for records that fall within a certain date range, use combinations of the >, <, >=, and <= comparison operators.
Logical operators
A logical operator is a keyword that connects two or more expressions to create a compound expression.
Some Platform APIs services enable you to create complex queries by stringing together multiple property value filters using logical operators.
The filter keyword supports logical queries that return records based on complex queries that compare the value of expressions.
The Platform APIs enables you to create complex expressions using the AND and the OR logical operators:
| Operator | Description |
|---|---|
AND | In an complex expression using the AND logical operator, both expressions must be true for the complex expression to be true. |
OR | In an complex expression using the OR logical operator, either expression may be true for the complex expression to be true. |
The following request defines a query string that evaluates two expressions using the AND and OR logical operators.
curl --request GET \
--url 'https://{host}/platform/riskdata/v1/exposures/67/portfolios? \
filter=portfolioNumber%20 \
LIKE%20%22Portfolio_%2A%22%20 \
AND%20%28description%20%3D%201%29%20
OR%20ownerName%3D%22max%22%29' \
--header 'accept: application/json'
Exposure property filters
The Platform APIs support query filters for a limited number of exposure properties. Depending on the exposure type (account, aggregate portfolio, portfolio, and treaty), records could be filtered using query parameters.
Your ability to filter exposures, the comparison operators supported, depend on the data type of the property. Platform APIs support the filtering of strings, dates, and numbers.
Accounts
The Search Accounts operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
accountid | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
accountName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
accountNumber | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
branchName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
cedantName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
locationsCount | Number | =,!=, >, <, >=, <= | IN, NOT IN | AND, OR |
ownerName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | |
policyExpirationDateTo | YYYY-MM-DD | =, !=, >, <, >=, <= | AND, OR | |
producerName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
reportsCount | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
resultsCount | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
stampDate | YYYY-MM-DD | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
underwriterName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
userId1 | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
userId2 | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
userId3 | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
userId4 | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
userText1 | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
userText2 | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
Aggregate portfolios
The Search Aggregate Portfolios operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
aggregatePortfolioId | Number | =, !=, >, <, >=, <= | IN, NOT IN, | AND, OR |
aggregatePortfolioName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
aggregatePortfolioNumber | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
cedantId | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
cedantName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
createDate | YYYY-MM-DD | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
currency | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
ownerName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
source | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
Branches
The Search Branches operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
branchid | String | =, !=, >, <, >=,<= | IN, NOT IN | AND, OR |
branchName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
Cedants
The Search Cedants operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
cedantId | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
cedantName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
Databases
The Search Databases operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
databaseId | String | =, != | IN, NOT IN | AND, OR |
databaseName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
databaseType | String | =, != | IN, NOT IN | AND, OR |
databaseVersion | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
Data Servers
The Search Data Servers operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
serverName | String | = | AND, OR | |
serverType | String | = | AND, OR |
EDMs
The Search EDMs operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
exposureId | Number | =, !=, >, <, >=,<= | IN, NOT IN | AND, OR |
exposureName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
ownerName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
serverName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
status | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
Exposure sets
The Search Exposure Sets operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
exposureSetId | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
exposureSetName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
Facultatives
The Search Facultatives operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
facultativeId | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
facultativeName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
Risk Data jobs
The Search Risk Data Jobs operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
endedAt | YYYY-MM-DD | = | AND | |
jobId | Number | = | AND | |
name | String | = | AND | |
status | String | = | AND | |
type | String | = | AND | |
userName | String | = | AND |
Lines of business
The Search Lines of Business operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
lobId | Number | =, !=, >, <, >=,<= | IN, NOT IN | AND, OR |
lobName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
Locations
The Search Locations operation returns a list of accounts. This operation supports complex queries based the following properties.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
accountId | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
addressType | String | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
admin1Code | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
admin1Name | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
admin2Code | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
admin2Name | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
admin3Code | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
admin3Name | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
admin4Code | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
admin4Name | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
area | Number | =, !=, > <, >=, <= | IN, NOT IN | AND, OR |
areaUnit | Number | =, !=, > <, >=, <= | IN, NOT IN | AND, OR |
bldgHeight | Number | =, !=, > <, >=, <= | IN, NOT IN | AND, OR |
bldgValuation | Number | =, !=, > <, >=, <= | IN, NOT IN | AND, OR |
block | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
blockGroup | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
buildingClass | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
buildingClassScheme | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
buildingId | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
buildingName | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
buildings | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
cityCode | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
cityName | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
contentLossTrigger | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
country | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
countryRmsCode | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
countryScheme | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
currency | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
dwellTime | Number | =, !=, > <, >=, <= | IN, NOT IN | AND, OR |
expireDate | YYYY-MM-DD | =, !=, >, <, >=, <= | AND, OR | |
floodDefHtAboveGrnd | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
floodDefenseElevation | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
| `floodDefenseElevationUnit | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
floorArea | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
floorOccupancy | String | =, !=, LIKE NOT LIKE | IN, NOT IN | AND, OR |
geoResolutionCode | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
heightUnit | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
huZone | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
inceptDate | YYYY-MM-DD | =, !=, >, <, >=, <= | AND, OR | |
isPrimaryBldg | Boolean | =, != | IN, NOT IN | AND, OR |
latitude | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
locationCode | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
locationId | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
locationName | String | =, !=, LIKE, LIKE NOT | IN, NOT IN | AND, OR |
locationNumber | String | =, !=, LIKE NOT, LIKE | IN,NOT IN | AND, OR |
longitude | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
mfdSubcategory | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
nship | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
occupancyType | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
occupancyTypeScheme | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
otherZone | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
postalCode | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
propertyReference | String | =, != LIKE NOT, LIKE | IN, NOT IN | AND, OR |
rentalPropertyIdentifier | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
siteName | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
slope | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
stories | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
streetAddress | String | =, !=, LIKE, LIKE NOT | IN, NOT IN | AND, OR |
tiv | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
updateDate | YYYY-MM-DD | =, !=, >, <, >=, <= | AND, OR | |
useContentValue | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
userBfe | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
userGroundElev | Number | =, !=,>, <, >=, <= | IN, NOT IN | AND, OR |
userId1 | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
userId2 | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
userText1 | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
userText2 | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
yearBuilt | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
zone1 | String | =, !=, LIKE NOT, LIKE | IN, NOT IN | AND, OR |
zone3Name | String | =, != LIKE NOT, LIKE | IN, NOT IN | AND, OR |
zone4Name | String | =, != LIKE NOT, LIKE | IN, NOT IN | AND, OR |
Portfolios
The Search Portfolios operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
createDate | YYYY-MM-DD | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
description | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
ownerName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
portfolioId | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
portfolioName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
portfolioNumber | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
stampDate | YYYY-MM-DD | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
Producers
The Search Producers operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
producerId | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
producerName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
Treaties
The Search Treaties operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
aggregateDeductible | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
aggregateLimit | Number | =, !=, >, <, >=,<= | IN, NOT IN | AND, OR |
attachmentBasis | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
attachmentLevel | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
attachmentPoint | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
cedant | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
currency | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
isValid | Boolean | =, != | IN, NOT IN | AND, OR |
maolAmount | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
numberOfReinstements | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
occurrrenceLimit | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
percentageCovered | Number | =, !=, >, <, >=,<= | IN, NOT IN | AND, OR |
percentagePlaced | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
percentageRetention | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
percentageRiShare | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
premium | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
priorty | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
producer | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
reinstatementCharge | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
retentionAmount | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
riskLimit | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
treatyId | Number | =, !=, >, <, >=, <= | IN, NOT IN | AND, OR |
treatyName | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
treatyNumber | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
treatyType | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
userId1 | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
userId2 | String | =, !=, LIKE, NOT LIKE | IN, NOT IN | AND, OR |
Enrich Exposure Jobs
The Search Enrich Exposure Jobs operation returns a list of Enrich Exposure API jobs. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
endedAt | = | |||
jobId | = | IN | ||
name | = | |||
startedAt | = | |||
status | = | |||
type | = | |||
userName | = |
Tenant Jobs
The Search Tenant Jobs operation returns a list of accounts. This operation supports complex queries based the following properties and a combination of comparison operators, list operators, and logical operators.
| Property | Data Type | Comparison | List | Logical |
|---|---|---|---|---|
endedAt | YYY-MM-DD | = | AND | |
entitlement | String | IN | ||
jobId | Number | = | ||
name | String | =, LIKE | ||
platformOperationType | = | IN | ||
startedAt | YYY-MM-DD | = | AND | |
status | String | = | ||
type | String | = | ||
userName | String | = |
Result property filters
EP curve type filters
The epType query parameter enables you to filter metrics by EP curve types. Options include AEP, OEP, TCE_AEP, and TCE_OEP.
An EP curve is a cumulative distribution showing the probability that losses will exceed a certain amount, from either single or multiple occurrences. Losses are expressed in the occurrence exceedance probability (OEP) and the aggregate exceedance probability (AEP) curves.
For example, the Get Metrics operation supports filtering by EP type:
curl --request GET \
--url 'https://{host}/riskmodeler/v2/analyses/analysisID/metrics?granularity=POLICY& \
epType=AEP& \
epType=TCE_AEP& \
limit=100& \
offset=0' \
--header 'Authorization: XXXXXXXXXX' \
--header 'accept: application/json'
Platform APIs support the following EP curve type query parameters as filters:
| Code | Description |
|---|---|
AEP | Probability that the total losses across all events in a year will meet or exceed a loss threshold. |
OEP | Probability that at least one event will occur in a year that causes losses greater than or equal to a certain amount. |
TCE_AEP | TCE is the expected value of loss given that a loss at least as large as RPLα has occurred based on AEP losses. Conditional expectation of losses that are greater than or equal to a specified loss threshold RPLα, where α is the selected risk tolerance threshold and RPLα is the corresponding is the return period loss. |
TCE_OEP | TCE is the expected value of loss given that a loss at least as large as RPLα has occurred based on AEP losses. Conditional expectation of losses that are greater than or equal to a specified loss threshold RPLα, where α is the selected risk tolerance threshold and RPLα is the corresponding return period loss. |
Event ID filters
The eventIds query parameter enables you to filter result metrics by event IDs.
An event is a representation of a peril (e.g. earthquake, flood, hurricane) with the potential to generate catastrophe losses. For a given peril, all potential events are synthesized into a stochastic event set, which defines the occurrence and magnitude of each event. Events within an event set are identified by a unique event ID.
The Get ELT and Get Sampled Losses operations supports filtering by Event IDs.
curl --request GET \
--url 'https://{host}/riskmodeler/v2/analyses/id/elt?perspective=RN& \
treatyId=56& \
eventIds=6789& \
eventIds=6790& \
eventIds=6791 \
--header 'Authorization: XXXXXXXXXX' \
--header 'accept: application/json'
Exposure ID filters
The exposureId query parameter enables you to filter metrics by exposure ID.
An exposure is an entity that may produce a financial loss when impacted by an event. Exposures are identified by their exposure type and a unique ID number.
The exposure ID identifies the exposure (e.g. location, account, portfolio) analyzed.
The Get ELT, Get EP Metrics, Get EP Interpolation, Get Key Losses, Get PLT, Get Sampled Losses, and Get Statistics operations support filtering by exposure IDs.
curl --request GET \
--url 'https://{host}/riskmodeler/v2/analyses/id/elt?exposureId=45' \
--header 'Authorization: XXXXXXXXXX' \
--header 'accept: application/json'
Exposure type filters
The exposureType query parameter enables the client to filter perspectives by exposure type. If unspecified, the service uses the default value of 0 and returns all exposure types.
Each exposure type is identified by a four-digit numberic code, e.g. 8017 (Portfolio or Group), 8019 (Account), 8020 (Location).
The Get ELT, Get EP Metrics, Get EP Interpolation, Get Key Losses, Get Financial Perspectives, Get PLT, Get Sampled Losses, and Get Statistics operations support filtering by exposure IDs.
curl --request GET \
--url 'https://{env_url}/riskmodeler/v2/analyses/35/keylosses?exposureType=8020'
The exposureType query parameter may be defined by the following values:
| ID | Description |
|---|---|
0 | Default. Returns perspectives for all exposure types. |
7937 | Treaty |
7938 | PortByCedant |
7939 | AccountCoverage |
7940 | EQLocationCvgDetail |
7941 | HULocationCvgDetail |
7942 | TOLocationCvgDetail |
7943 | PortByRegion |
7950 | PortByPostCode |
7951 | portbypostcodelob |
7952 | portbyloccode |
7953 | portbyloccodelob |
7954 | portbydistrict |
7955 | portbydistrictlob |
7956 | portbycity |
7957 | portbycitylob |
7958 | portbycounty |
7959 | portbycountylob |
7960 | portbycresta |
7961 | portbycrestalob |
7962 | portbystate |
7963 | portbystatelob |
7964 | portbylob |
7965 | portinjurylevel |
7966 | acctinjurylevel |
7967 | policyinjurylevel |
7968 | locationinjurylevel |
7969 | locpeoplegroupinjurylevel |
7970 | policyspecialconditions |
7971 | buildingcoverage |
7972 | buildinginjurylevel |
7975 | portbycountry |
7976 | portbycountrybylob |
7981 | portbycountybycedant |
7982 | portbycrestabycedant |
7983 | portbystatebycedant |
7984 | portbycountrybycedant |
7986 | portbypostcodebylobbycedant |
7990 | portbycountylobbycedant |
7991 | portbycrestalobbycedant |
7992 | portbystatelobbycedant |
7993 | portbycountrybylobbycedant |
8017 | portfolio |
8019 | account |
8020 | location |
8021 | policy |
8022 | locationcoverage |
8023 | policycoverage |
8024 | reinsurancecession |
8025 | eqlocationdetail |
8026 | hulocationdetail |
8027 | tolocationdetail |
8028 | fllocationdetail |
8029 | aggportfolio |
8030 | portfoliocoverage |
8031 | locationpeoplegroup |
8035 | building |
9000 | fac |
Filter condition filters
The filterCondition query parameters enable you to filter metrics by job IDs.
The Get Metrics operation supports filtering by return periods and filter conditions.
curl --request GET \
--url 'https://{host}/riskmodeler/v2/analyses/analysisID/metrics?returnPeriod=33&filterCondition=condition&limit=100&offset=0' \
--header 'Authorization: XXXXXXXXXX' \
--header 'accept: application/json'
Granulariy filters
The granularity query parameters enable you to filter metrics by output levels.
The Get Metrics operation supports filtering by the POLICY granularity.
curl --request GET \
--url 'https://{host}/riskmodeler/v2/analyses/analysisID/metrics?granularity=POLICY& \
epType=AEP& \
epType=TCE_AEP& \
limit=100& \
offset=0' \
--header 'Authorization: XXXXXXXXXX' \
--header 'accept: application/json'
Job ID filters
The jobId query parameters enable you to filter metrics by job IDs.
The jobId parameter is supported by all Platform APIs GET operations in the Metrics collection.
curl --request GET \
--url 'https://{host}/riskmodeler/v1/analyses/analysisID/elt?perspective=GU& /
jobUUID=a433baa3-8e1e-47ff-8098-f8781d9b3c32& /
exposureId=8& /
exposureType=8017& /
jobId=134866' /
--header 'Authorization: XXXXXXXXXX' \
--header 'accept: application/json'
Job UUID filters
The jobuuid query parameters enable you to filter metrics by job UUIDs.
The jobUUID parameter is supported by all Platform APIs GET operations in the Metrics collection.
curl --request GET \
--url 'https://{host}/riskmodeler/v1/analyses/analysisID/elt?perspective=GU& /
jobUUID=a433baa3-8e1e-47ff-8098-f8781d9b3c32& /
exposureId=8& /
exposureType=8017& /
jobId=9064540' /
--header 'Authorization: XXXXXXXXXX' \
--header 'accept: application/json'
Key and value filters
The key and value query parameters enable you to filter metrics by key-value properties.
The Get EP Interpolation operation supports filtering by keys and key values.
curl --request GET \
--url 'https://{host}/riskmodeler/v2/analyses/id/ep/interpolate?key=key& \
value=value' \
--header 'Authorization: XXXXXXXXXX' \
--header 'accept: application/json'
Metric type filters
The metricType query parameter enables you to filter analysis result data based on the metrics.
The Get EP Metrics, Get EP Interpolation, and Get Metrics operation supports filtering by metric types. One of ELT, EP, or STATS.
curl --request GET \
--url 'https://{host}/riskmodeler/v2/analyses/45/ep?metricType=ELT'
Platform APIs support the following metric type parameter values:
| Code | Description |
|---|---|
| `ELT | The event loss table (ELT) is an output table that contains the mean loss standard deviation, exposure value, and event rate for every loss-causing event. In DLM models, the ELT is the basis of losses for all financial perspectives at all exposure levels. To learn more, see Event loss tables |
EP | EP metrics measure the probability that an event will occur in a year that causes losses greater than or equal to a certain amount. To learn more, see EP metrics |
STATS | Statistics include the average annual loss, standard deviation, and coefficient of variation. To learn more, see Statistics |
Perspective filters
The perspective query parameter identifies the financial perspective. Financial perspectives are identified by a two-character string.
The Get Cedants by Result, Get ELT, Get EP Interpolation, Get Key Losses, Get Location AAL Metrics, Get Metrics, Get PLT, Get Sampled Losses, and Get Statistics operations support filtering by financial perspective.
curl --request GET \
--url 'https://{env_url}//riskmodeler/v2/analyses/34/location-aal?perspective=GR \
&sort=AAL%20DESC \
&limit=100 \
&offset=0'
Platform APIs support the following perspective query parameters as filters:
| Code | Description |
|---|---|
GU | Ground Up Loss |
GS | Ground Up Specified Loss |
G2 | Ground Up Loss - Secondary Peril |
G1 | Ground Up Loss - Primary Peril |
CL | Client Loss |
UC | Underlying Coverage |
OL | Over Limit Loss |
OI | Other Insurer’s Loss |
GR | Gross Loss |
FA | Faculative Reinsurance Loss |
SS | Surplus Share Treaty Loss |
QS | Quota Share Treaty Loss |
WX | Working Excess Treaty Loss |
RL | New Loss Pre Cat |
RP | Net Loss Post Cat |
RC | Net Loss Post Corporate Cat |
RG | Reinsurance Gross Loss |
RN | Reinsurance New Loss |
Financial perspectives are understood to be upstream or downstream of one another. The position of one perspective relative to one another perspective is an important factor in financial perspective mapping. For more information, see Map perspective by analysis.
Return period filters
The returnPeriod query parameter enables you to filter by return period.
A return period is a point on an EP curve that describes the likelihood of exceeding a loss threshold from the single largest event (OEP) or the aggregation of one or more events (AEP). The return period is defined as the inverse of the annual exceedance probability. For example, a return period of 100 years corresponds to an annual exceedance probability of 1%. In the context of peril events, return period refers to the number of years between occurrences of an event of a given size in the region. Short and long return periods enable modelers to estimate risk at both short and long-range exceedance probabilities.
The Get Metrics operation supports filtering by return periods. Must be a value between 2 and 49999.
curl --request GET \
--url 'https://{host}/riskmodeler/v2/analyses/analysisID/metrics?returnPeriod=2500& \
limit=100& \
offset=0' \
--header 'Authorization: XXXXXXXXXX' \
--header 'accept: application/json'
Run date filters
The runDate query parameter enables you to filter analysis results by the date the analysis was processed.
The Get Results operation supports filtering by run date.
curl --request GET \
--url 'https://{host}/riskmodeler/v2/[email protected]& \
runDate=2022-12-23'
Treaty ID filters
The treatyId query parameter enables you to filter analysis results by treaty ID.
By viewing losses at the treaty-level, you can better assess capacity and coverage and make corresponding pricing decisions.
The Get EP Metrics, Get ELT, Get EP Interpolation, Get key Losses, Get PLT, Get Sampled Losses, and Get Statistics operations support treaty ID filtering.
curl --request GET \
--url 'https://{host}/riskmodeler/v2/analyses/id/elt?perspective=RN& \
treatyId=56& \
eventIds=6789& \
eventIds=6790& \
eventIds=6791 \
--header 'Authorization: XXXXXXXXXX' \
--header 'accept: application/json'
User name filters
The userName query parameter enables you to filter analysis results by the name of the principal that submitted that analysis job.
A principal is an entity that identifies an authorized end user or client application. Intelligent Risk Platform supports two principals: user accounts for end users of applications and API keys for client applications. Principals gain access rights and permissions to protected resources by being members of a group that has been granted those access rights and permissions.
For example, the Get Results operation supports user name filtering.
curl --request GET \
--url 'https://{host}/riskmodeler/v2/analyses?userName=p_name& \
runDate=date-string'
Updated 20 days ago