VerificationTier

Description

A tiered grouping of the verification evidence Enigma has gathered for a legal entity, alongside the underlying signals that drove the grouping. Each tier corresponds to a level of independence and resistance to manipulation in the evidence: higher tiers require evidence that comes from independent third parties and is harder for an actor to fabricate.

How to act on a given tier — for example, what threshold should gate onboarding or what should trigger manual review — depends on the policy and risk appetite of the consuming application. The per-tier signals are exposed alongside the overall tier so applications can either use the tier directly or compose their own logic on top of the signals.

Tiers

The verification_tier field reflects the strongest tier for which the legal entity has at least one positive signal.

**tier_3**: At least one signal that is hard to manipulate and comes from an independent third party is present — for example, a verified open operating location, sustained card-transaction activity with positive revenue over a twelve-month period, a long and dense customer review history across active locations, or a record sourced from a government agency.
**tier_2**: Signals that can still be fabricated but require meaningful effort are present — customer reviews across active operating locations or a working website associated with the legal entity's brands.
**tier_1**: Only signals that an actor could produce quickly and with little effort are present — a corporate registration (of any status) or an Employer Identification Number (EIN) that Enigma has on record.
**none**: Reserved. Not produced in the current implementation: the universe is gated to legal entities with at least one corporate registration of any status, so every output row reaches at least Tier 1.

type VerificationTier implements NodeFunctions {
  firstObservedDate: String
  lastObservedDate: String
  verificationTier: String
  rank: Int
  tier1Signals: JSON
  tier2Signals: JSON
  tier3Signals: JSON
  internalId: String
  internalLegalEntityId: String
  id: UUID!
  count(
    field: String!
    conditions: Conditions
    dataLayer: DataLayer
  ): Int
  countDistinct(
    field: String!
    conditions: Conditions
  ): Int
  has(
    field: String!
    conditions: Conditions
  ): Boolean
  sum(
    field: String!
    conditions: Conditions
  ): Int
  min(
    field: String!
    conditions: Conditions
  ): Int
  max(
    field: String!
    conditions: Conditions
  ): Int
  avg(
    field: String!
    conditions: Conditions
  ): Float
  collect(
    field: String!
    separator: String
    conditions: Conditions
  ): String
  minDateTime(
    field: String!
    conditions: Conditions
  ): DateTime
  maxDateTime(
    field: String!
    conditions: Conditions
  ): DateTime
  _fn: JSON
}

Fields

`VerificationTier.firstObservedDate` ● `String` scalar

`VerificationTier.lastObservedDate` ● `String` scalar

`VerificationTier.verificationTier` ● `String` scalar

The strongest tier of evidence Enigma has gathered for the legal entity. One of tier_3, tier_2, tier_1.

`VerificationTier.rank` ● `Int` scalar

Determines the display order of the attribute, with lower values shown first

`VerificationTier.tier1Signals` ● `JSON` scalar

Tier 1 evidence — trust-based signals an actor could produce quickly and with little effort: a corporate registration of any status and an EIN on record with Enigma.

`VerificationTier.tier2Signals` ● `JSON` scalar

Tier 2 evidence — signals that can still be fabricated but require meaningful effort: customer reviews at active locations and a working web presence.

`VerificationTier.tier3Signals` ● `JSON` scalar

Tier 3 evidence — hard-to-manipulate signals from independent third parties: currently-Open locations, sustained card-transaction activity with positive revenue, a substantial review history at active locations, and appearance in a government record.

`VerificationTier.internalId` ● `String` scalar

`VerificationTier.internalLegalEntityId` ● `String` scalar

`VerificationTier.id` ● `UUID!` non-null scalar

`VerificationTier.count` ● `Int` scalar

`VerificationTier.count.field` ● `String!` non-null scalar

`VerificationTier.count.conditions` ● `Conditions` input

`VerificationTier.count.dataLayer` ● `DataLayer` enum

The layer of records count(field: "records") counts on a search's own legal entities, persons and addresses and on the Record a search with entityType RECORD returns; UNGROUNDED on a legal entity, person or address below a search's own results is an error, and every other count ignores dataLayer. GROUNDED counts the records linked in the graph; UNGROUNDED counts gov-archive store records: on a legal entity, person or address, each record once whose asserted entity's value is wholly, case and separators aside, one of its names or its full address (ACME INC counts no record of ACME INC OF TEXAS), and on that Record, every record the store finds for the search. Without dataLayer, GROUNDED, but on the Record of an UNGROUNDED search the records of both, a record in both counted once. Null, with an error, where the records cannot all be counted, such as past 5 seconds or on a result with more than 20 values.