> ## Documentation Index
> Fetch the complete documentation index at: https://developers.activeprospect.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Claiming a Certificate

> TrustedForm account holders who are receiving certified leads can use the
TrustedForm API to claim the certificate provided with each lead. Doing so

1. Verifies the legitimacy of the certificate
2. Stores the certificate for future reference and
3. Provides programmatic access to the information shown on the certificate

To claim a certificate using the TrustedForm API, send an HTTP POST request
to the certificate URL sent by your publisher.

Do not make a request unless the URL starts with
https://cert.trustedform.com, otherwise you may expose your TrustedForm
credentials to someone else

- Use a POST request — any other type of request will not claim the
  certificate
- Use the Accept: application/json request header
- Use the Content-Type: application/json or Content-Type:
  application/x-www-form-urlencoded header, and encode the request body
  accordingly.
- In the Authorization header, use the API key provided on the "Settings"
  tab in the TrustedForm Application and the username 'API'.

### Page Scanning

As part of the claiming process, it's often required that certain language
either exists or doesn't exist on the page. For example, you may want to
ensure certain consent language exists. As another example, you may want
to ensure other language does not exist, such as "free iPhone".

#### Page Scanning Params

You can use the `required_scan_terms` and `forbidden_scan_terms`
parameters.

- `required_scan_terms`: Use this parameter to scan for language you want to ensure exist
  on the page.
- `forbidden_scan_terms`: Use this parameter to scan for language you want to ensure does
  not exist on the page.

Often, you will want to scan against a variety of possible texts. The TrustedForm Claiming API enables you to do this in three ways:

1. Send the variations as a list using `required_scan_terms[]` or `forbidden_scan_terms[]`
2. Use wildcards in the consent language.
3. Use templates.

You can use a mixture of all three.

#### Wildcards

Use `{{*}}` in the consent language you wish to scan for as a wildcard.
For Example, passing "on behalf of `{{*}}` at the telephone number" will
match "on behalf of Mortgage Acme at the telephone number".

Like using exact language, scans using wildcards can be sent in as
an array.

#### Templating

Templating is different than other versions of page scanning in that you
must 1) send it as JSON (i.e. Content-type of application/json); 2)
provide a list of key/values to use in the template.

If we were to use the example from above, we might use the following
templates:

```json
{
  "required_scan_terms": [
    {
      "template": "on behalf of {{company}} at the telephone number",
      "variables": [
        {"company": "Mortgage Acme"},
        {"company": "Acme Mortgage"},
        {"company": "Acme Co."}
      ]
    },
    {
      "template": "on behalf of {{company}} at the {{contact_method}}",
      "variables": [
        {"company": "Mortgage Acme", "contact_method": "email"},
        {"company": "Acme Mortgage", "contact_method": "fax number"},
        {"company": "Acme Mortgage", "contact_method": "email"},
        {"company": "Acme Co.", "contact_method": "email"}
      ]
    }
  ]
}
```

#### Scan Delimiters

When using wildcards in page scans and page scan templates, the default
method is to surround the wildcard or template key with "handlebar" braces
(`{{}}`). If that conflicts with your system, you can provide your own
delimiter to use. Currently, TrustedForm only allows homogeneous delimiters
(i.e. the beginning and end are the same character(s)) such as `**`, `|`, or
even `+++`.

### Sandboxed Certificates

Certificates created with the `sandbox` flag set to `true` cannot be
claimed.




## OpenAPI

````yaml /api-reference/trustedform_v3.json post /{cert_id}
openapi: 3.0.0
info:
  contact:
    email: support@activeprospect.com
    name: ActiveProspect Support Team
    url: https://support.activeprospect.com
  description: >
    # Overview


    ## Claiming


    Claiming a certificate will allow you to verify its legitimacy, view it

    online, access its data via our API, and refer to the snapshot that was

    taken of the page as seen by the consumer, for up to 30 days. And you

    can easily configure your account to keep certificates for as long as

    you like, for a small additional fee.


    ### Claim Period


    The "claim period" is the time in which a TrustedForm Certificate must

    be claimed or extended by a TrustedForm Account holder. If it's not, it

    will expire.


    * The standard claim period is approximately 72 hours (3 days).

    * The extended claim period is approximately 2,160 hours (90 days).


    Within the claim period, TrustedForm Certificates are visible to anyone

    with access to the TrustedForm Certificate URL. After this period,

    TrustedForm Certificates are only accessible by the TrustedForm account

    holders that claimed them.


    ## Extended Certs


    By default, Web Certs have a 72-hour (3 days) window in which they can

    be claimed. This window is automatically expanded to 90 days if we

    detect the form's submission.


    If you have need to extend Certs beyond the default 3-day window, you

    have a couple options:


    1. Cert check-in

    2. Enable extended claims


    ### Cert Check-in


    ActiveProspect provides TrustedForm Check-in to allow TrustedForm

    account holders to extend the claim period of certificates beyond the

    standard claim period. Checking a certificate in extends the claim

    period without the need to either claim the certificate or have

    "Extended Claims" enabled on the publishing account.


    ### Enable Extended Claims


    When you enable extended claims, Certificates you claim will

    automatically be extended and available to be claimed up to 90 days.


    Reach out to your account representative to enable extended claims.


    ## Ping (Deprecated)


    The TrustedForm Ping API is meant to be used by lead buyers purchasing

    leads using the "ping/post" model. This API gives buyers access to that

    data with the intention that it will be called when the buyer is

    evaluating a ping request from a seller. The buyer can then use the

    returned data to set an appropriate bid price.


    ### Comparison to Claim API


    The Ping API does not replace the TrustedForm Claim process. The Ping

    API cannot be used to verify or store consent for TCPA compliance. It

    does not support page scanning, fingerprinting, replay, or certificate

    storage.


    Please refer to the [Getting Started with
    Claiming](/pages/trustedform/getting-started)

    for details on claiming a certificate.


    # Other information


    ## Prerequisites


    * [Add the TrustedForm
    script](https://activeprospect.com/products/trustedform-for-publishers/) to
    your lead forms.

    * Contact support@activeprospect.com to receive an API key.
  termsOfService: https://activeprospect.com/trustedform-eula
  title: TrustedForm Claiming API
  version: 3.0.0
servers:
  - description: The base URL for production.
    url: https://cert.trustedform.com
    variables: {}
security: []
tags: []
externalDocs:
  description: ActiveProspect Community
  url: https://developers.activeprospect.com/
paths:
  /{cert_id}:
    post:
      tags:
        - Claiming Certificates
      summary: Claiming a Certificate
      description: >
        TrustedForm account holders who are receiving certified leads can use
        the

        TrustedForm API to claim the certificate provided with each lead. Doing
        so


        1. Verifies the legitimacy of the certificate

        2. Stores the certificate for future reference and

        3. Provides programmatic access to the information shown on the
        certificate


        To claim a certificate using the TrustedForm API, send an HTTP POST
        request

        to the certificate URL sent by your publisher.


        Do not make a request unless the URL starts with

        https://cert.trustedform.com, otherwise you may expose your TrustedForm

        credentials to someone else


        - Use a POST request — any other type of request will not claim the
          certificate
        - Use the Accept: application/json request header

        - Use the Content-Type: application/json or Content-Type:
          application/x-www-form-urlencoded header, and encode the request body
          accordingly.
        - In the Authorization header, use the API key provided on the
        "Settings"
          tab in the TrustedForm Application and the username 'API'.

        ### Page Scanning


        As part of the claiming process, it's often required that certain
        language

        either exists or doesn't exist on the page. For example, you may want to

        ensure certain consent language exists. As another example, you may want

        to ensure other language does not exist, such as "free iPhone".


        #### Page Scanning Params


        You can use the `required_scan_terms` and `forbidden_scan_terms`

        parameters.


        - `required_scan_terms`: Use this parameter to scan for language you
        want to ensure exist
          on the page.
        - `forbidden_scan_terms`: Use this parameter to scan for language you
        want to ensure does
          not exist on the page.

        Often, you will want to scan against a variety of possible texts. The
        TrustedForm Claiming API enables you to do this in three ways:


        1. Send the variations as a list using `required_scan_terms[]` or
        `forbidden_scan_terms[]`

        2. Use wildcards in the consent language.

        3. Use templates.


        You can use a mixture of all three.


        #### Wildcards


        Use `{{*}}` in the consent language you wish to scan for as a wildcard.

        For Example, passing "on behalf of `{{*}}` at the telephone number" will

        match "on behalf of Mortgage Acme at the telephone number".


        Like using exact language, scans using wildcards can be sent in as

        an array.


        #### Templating


        Templating is different than other versions of page scanning in that you

        must 1) send it as JSON (i.e. Content-type of application/json); 2)

        provide a list of key/values to use in the template.


        If we were to use the example from above, we might use the following

        templates:


        ```json

        {
          "required_scan_terms": [
            {
              "template": "on behalf of {{company}} at the telephone number",
              "variables": [
                {"company": "Mortgage Acme"},
                {"company": "Acme Mortgage"},
                {"company": "Acme Co."}
              ]
            },
            {
              "template": "on behalf of {{company}} at the {{contact_method}}",
              "variables": [
                {"company": "Mortgage Acme", "contact_method": "email"},
                {"company": "Acme Mortgage", "contact_method": "fax number"},
                {"company": "Acme Mortgage", "contact_method": "email"},
                {"company": "Acme Co.", "contact_method": "email"}
              ]
            }
          ]
        }

        ```


        #### Scan Delimiters


        When using wildcards in page scans and page scan templates, the default

        method is to surround the wildcard or template key with "handlebar"
        braces

        (`{{}}`). If that conflicts with your system, you can provide your own

        delimiter to use. Currently, TrustedForm only allows homogeneous
        delimiters

        (i.e. the beginning and end are the same character(s)) such as `**`,
        `|`, or

        even `+++`.


        ### Sandboxed Certificates


        Certificates created with the `sandbox` flag set to `true` cannot be

        claimed.
      operationId: ClaimerWeb.ClaimController.create
      parameters:
        - description: >
            Can be either `application/json` or
            `application/x-www-form-urlencoded`.
          in: header
          name: Content-type
          required: true
          schema:
            type: string
        - description: Certificate ID
          in: path
          name: cert_id
          required: true
          schema:
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ClaimRequest'
        description: Claiming Parameters
        required: false
      responses:
        '201':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ClaimResponse'
          description: Claim Created Response
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BadRequest'
          description: Malformed Certificate URL
        '401':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Unauthorized'
          description: Unauthorized
        '402':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PaymentRequired'
          description: Account is inactive or out of funds
        '404':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/NotFound'
          description: TrustedForm certificate has expired or could not be found
        '405':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MethodNotAllowed'
          description: Attempted to claim a 'sandboxed' certificate
        '422':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnprocessableEntity'
          description: The certificate has been claimed too many times
      callbacks: {}
      security: []
components:
  schemas:
    ClaimRequest:
      description: POST body for claiming a cert
      example:
        email_1: user@example.com
        forbidden_scan_terms: I do not agree to the terms of service
        phone_1: 999-999-0909
        reference: '1128238382829'
        required_scan_terms: I agree to the terms of service
        vendor: Acme Co.
        campaign_id: summer_promo_2021
      properties:
        campaign_id:
          description: >-
            An optional identifier for the campaign associated with the lead.
            Use this to track which campaign generated the lead without relying
            on the vendor field. TrustedForm will record this value on the
            certificate stored in your account and include it in reporting.
          type: string
        email:
          description: >
            When claiming a certificate, you can pass an optional email (or
            email_1, email_2, etc)

            parameter. TrustedForm will extract the email value and perform
            fingerprinting

            against the available data.
          type: string
        fingerprints:
          description: >
            When you claim a certificate you can calculate lead fingerprint
            values

            using the email and phone number you received in the lead data

            accompanying the certificate. Each fingerprint value is an SHA1 hash
            of

            an email or phone value. Each fingerprint value should be provided
            in a

            fingerprint parameter.


            If none of the fingerprints you provide match a fingerprint
            collected on the

            certificate you will receive the "none of the provided fingerprints
            match"

            message in the claim warnings field. This indicates that the lead
            data

            collected on the form does not match the lead data that you
            received.
          type: string
        forbidden_scan_terms:
          description: >
            Use this parameter to perform a scan of the page for text that must
            not

            be present.  TrustedForm will then perform a case and whitespace

            insensitive search for the string. If the string is not found in the

            HTML document, then "string found in snapshot" will be included in

            the warnings key of the claim response.
          oneOf:
            - description: A single piece of text to scan for
              type: string
            - description: An array of strings to scan for.
              items:
                type: string
              type: array
            - $ref: '#/components/schemas/PageScan'
            - description: An array of template objects to scan for.
              items:
                $ref: '#/components/schemas/PageScan'
              type: array
        phone:
          description: >
            When claiming a certificate, you can pass an optional phone (or
            phone_1, phone_2, etc)

            parameter. TrustedForm will extract the phone number value and
            perform fingerprinting

            against the available data.
          type: string
        reference:
          description: >
            When you claim a certificate, you can include an optional parameter

            reference We will store this value in the certificate's claim
            record. A

            use case for the reference parameter is to add your unique lead

            identifier to the claim record, which will provide a reference point

            from the claim to the certified lead that you received.


            This will indicate which lead a certificate belongs to just by

            examining the certificate data. In the case that your publisher has

            passed you two leads with the same Certificate URL, this reference

            parameter will allow you to determine which lead it was originally

            passed with.
          type: string
        required_scan_terms:
          description: >
            Use this parameter to perform a scan of the page for required text.

            TrustedForm will then perform a case and whitespace insensitive
            search

            for the string. If the string is not found in the HTML document,
            then

            "string not found in snapshot" will be included in the warnings key
            of

            the claim response.
          oneOf:
            - description: A single piece of text to scan for
              type: string
            - description: An array of strings to scan for.
              items:
                type: string
              type: array
            - $ref: '#/components/schemas/PageScan'
            - description: An array of template objects to scan for.
              items:
                $ref: '#/components/schemas/PageScan'
              type: array
        scan_delimiter:
          description: >
            You can provide your own delimiter to use when wrapping wildcards or

            tempate variablies. Your choice of delimiter must be homogeneous
            (i.e.

            the beginning and end are the same character(s)), such as

            `|`, `==`, or `|||`.
          type: string
        vendor:
          description: |
            When claiming a certificate, you can pass the optional vendor
            parameter. This is intended for tracking the name of the company
            that provided the lead associated with the certificate. We will
            store this value in the certificate’s claim record. When you use
            TrustedForm reporting, you can easily filter or group by a vendor.
          type: string
      title: ClaimRequest
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.ClaimRequestV3
    ClaimResponse:
      oneOf:
        - $ref: '#/components/schemas/ConsentClaimResponse'
        - $ref: '#/components/schemas/ConsentAndInsightsClaimResponse'
        - $ref: '#/components/schemas/RetainResponse'
        - $ref: '#/components/schemas/InsightsResponse'
      title: ClaimResponse
      x-struct: Elixir.ClaimerWeb.Schemas.LimitedOrFullClaim
    BadRequest:
      example:
        errors:
          detail: Malformed certificate id
        message: Malformed certificate id
        outcome: error
        reason: Malformed certificate id
      properties:
        errors:
          properties:
            detail:
              type: string
          type: object
        message:
          type: string
        outcome:
          type: string
        reason:
          type: string
      required:
        - errors
        - message
        - outcome
        - reason
      title: BadRequest
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.BadRequest
    Unauthorized:
      example:
        errors:
          detail: Unauthorized
        message: Unauthorized
        outcome: error
        reason: Unauthorized
      properties:
        errors:
          properties:
            detail:
              type: string
          type: object
        message:
          type: string
        outcome:
          type: string
        reason:
          type: string
      required:
        - errors
        - message
        - outcome
        - reason
      title: Unauthorized
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.Unauthorized
    PaymentRequired:
      example:
        errors:
          detail: Account is inactive
        message: Account is inactive
        outcome: error
        reason: Account is inactive
      properties:
        errors:
          properties:
            detail:
              type: string
          type: object
        message:
          type: string
        outcome:
          type: string
        reason:
          type: string
      required:
        - errors
        - message
        - outcome
        - reason
      title: PaymentRequired
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.PaymentRequired
    NotFound:
      example:
        outcome: error
        reason: TrustedForm certificate has expired or could not be found
      properties:
        outcome:
          type: string
        reason:
          type: string
      required:
        - outcome
        - reason
      title: NotFound
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.NotFound
    MethodNotAllowed:
      example:
        outcome: error
        reason: Certificate is not claimable
      properties:
        outcome:
          type: string
        reason:
          type: string
      required:
        - outcome
        - reason
      title: MethodNotAllowed
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.MethodNotAllowed
    UnprocessableEntity:
      example:
        outcome: error
        reason: Certificate has been claimed too many times
      properties:
        outcome:
          type: string
        reason:
          type: string
      required:
        - outcome
        - reason
      title: UnprocessableEntity
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.UnprocessableEntity
    PageScan:
      description: |
        A JSON object containing the template and variables to use for
        substitutions
      properties:
        template:
          description: >
            The template text to use when performing the page scan.  Variables

            defined in the text (using `{{variable_name}} will be substituted
            for

            those defined in the `variables` parameter.
          type: string
        variables:
          items:
            description: A list of key/value pairs as JSON objects.
            properties:
              key:
                description: |
                  replace `key` with the variable name you want to use
                type: string
              value:
                description: |
                  replace `value` with the value to replace the variable with
                type: string
          type: array
      title: PageScan
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.PageScan
    ConsentClaimResponse:
      example:
        fingerprints:
          matching:
            - c4a8e7fe184993964ae81380e91579015306838a
            - d511850d569bcd7802c30f54de34bb9f2b31eede
          non_matching:
            - d511850d569bcd7802c30f54de34bb9f2b31eed1
        is_masked: false
        masked_cert_url: https://example.com/1145b610ac97aa9f92d7cd2195446eac5e67ce53
        outcome: success
        scans:
          forbidden_found:
            - Enim sit amet venenatis
          forbidden_not_found:
            - Est velit egestas
          required_found:
            - lorem ipsum dolor
          required_not_found:
            - Ad qui aperiri
        warnings: []
      properties:
        fingerprints:
          $ref: '#/components/schemas/Fingerprints'
        is_masked:
          description: A boolean indicating whether the certificate is masked
          type: boolean
        masked_cert_url:
          description: A certificate url that masks the lead source url and snapshot
          nullable: true
          type: string
        outcome:
          default: success
          description: >
            The result of the attempt to verify consent. Success indicates that
            the certificate was

            claimed and did not generate any warnings related to consent
            verification. Failure indicates

            that the certificate was claimed but generated warnings because no
            fingerprints matched,

            forbidden scan terms were found or required scan terms were missing.
            Error indicates that

            the certificate was not claimed and the request should be reviewed
            and potentially retried.
          enum:
            - success
            - failure
            - error
          type: string
        reason:
          description: |
            Provides an explanation for failure or error.

            Only used for `outcome` of `failure` or `error`.
          type: string
        scans:
          $ref: '#/components/schemas/PageScans'
        warnings:
          description: |2
              An array of strings indicating possible issues with the certificate

              * `none of the provided fingerprints match`: No fingerprints matched.
              * `snapshot scan failed`: The snapshot was unable to be scanned.
              * `string not found in snapshot`: A required page scan text was not found.
              * `string found in snapshot`: A forbidden page scan text was found.
          items:
            enum:
              - none of the provided fingerprints match
              - snapshot scan failed
              - string not found in snapshot
              - string found in snapshot
            type: string
          type: array
      required:
        - outcome
        - masked_cert_url
        - is_masked
        - scans
        - fingerprints
      title: ConsentClaimResponse
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.ClaimConsentResponse
    ConsentAndInsightsClaimResponse:
      example:
        cert:
          age_seconds: 33
          approx_ip_geo:
            city: Austin
            country_code: US
            lat: 30.4548
            lon: -97.7664
            postal_code: '78729'
            state: TX
            time_zone: America/Chicago
          browser:
            full: Chrome 95.0.4638.69
            name: Chrome
            version:
              full: 95.0.4638.69
              major: '95'
              minor: '0'
              patch: '4638.69'
          cert_id: ddbb5429ca0063f857197df1a4638665bc143eee
          created_at: '2021-11-12T22:06:44Z'
          domain: example.com
          event_duration_ms: 21110
          expires_at: '2021-11-15T22:06:44Z'
          form_input_method:
            - typing
            - autofill
          ip: 8.8.8.8
          is_framed: true
          is_mobile: false
          kpm: 68.2314
          operating_system:
            full: Mac OS X 10.15.7
            name: Mac OS X
            version:
              full: 10.15.7
              major: '10'
              minor: '15'
              patch: '7'
          page_id: 5d8ce3c9502b426f77001ae7
          page_url: https://www.example.com/contact.html
          parent_page_url: https://www.example.com/index.html
          user_agent: >-
            Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36
            (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36
          wpm: 77.1234
        fingerprints:
          matching:
            - c4a8e7fe184993964ae81380e91579015306838a
            - d511850d569bcd7802c30f54de34bb9f2b31eede
          non_matching:
            - d511850d569bcd7802c30f54de34bb9f2b31eed1
        is_masked: false
        masked_cert_url: https://example.com/1145b610ac97aa9f92d7cd2195446eac5e67ce53
        outcome: success
        scans:
          forbidden_found:
            - Enim sit amet venenatis
          forbidden_not_found:
            - Est velit egestas
          required_found:
            - lorem ipsum dolor
          required_not_found:
            - Ad qui aperiri
        warnings: []
      properties:
        cert:
          $ref: '#/components/schemas/WebCertificate'
        fingerprints:
          $ref: '#/components/schemas/Fingerprints'
        is_masked:
          description: A boolean indicating whether the certificate is masked
          type: boolean
        masked_cert_url:
          description: A certificate url that masks the lead source url and snapshot
          nullable: true
          type: string
        outcome:
          default: success
          description: >
            The result of the attempt to verify consent. Success indicates that
            the certificate was

            claimed and did not generate any warnings related to consent
            verification. Failure indicates

            that the certificate was claimed but generated warnings because no
            fingerprints matched,

            forbidden scan terms were found or required scan terms were missing.
            Error indicates that

            the certificate was not claimed and the request should be reviewed
            and potentially retried.
          enum:
            - success
            - failure
            - error
          type: string
        reason:
          description: |
            Provides an explanation for failure or error.

            Only used for `outcome` of `failure` or `error`.
          type: string
        scans:
          $ref: '#/components/schemas/PageScans'
        warnings:
          description: |2
              An array of strings indicating possible issues with the certificate

              * `none of the provided fingerprints match`: No fingerprints matched.
              * `snapshot scan failed`: The snapshot was unable to be scanned.
              * `string not found in snapshot`: A required page scan text was not found.
              * `string found in snapshot`: A forbidden page scan text was found.
          items:
            enum:
              - none of the provided fingerprints match
              - snapshot scan failed
              - string not found in snapshot
              - string found in snapshot
            type: string
          type: array
      required:
        - outcome
        - cert
        - fingerprints
        - masked_cert_url
        - is_masked
        - scans
        - warnings
      title: ConsentAndInsightsClaimResponse
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.ClaimConsentAndInsightsResponse
    RetainResponse:
      example:
        is_retained: 'true'
        outcome: success
      properties:
        is_retained:
          description: |
            Set to true when the cert has been retained"
            Only used for `outcome` of `success`.
          type: boolean
        outcome:
          default: success
          description: >
            The result of the attempt to verify a cert was retained. Success
            indicates that the certificate was

            retained and did not generate any warnings related to consent
            verification. Failure indicates

            that the certificate was retained but generated warnings because no
            fingerprints matched,

            forbidden scan terms were found or required scan terms were missing.
            Error indicates that

            the certificate was not retained and the request should be reviewed
            and potentially retried.
          enum:
            - success
            - failure
            - error
          type: string
        reason:
          description: |
            Provides an explanation for failure or error.

            Only used for `outcome` of `failure` or `error`.
          type: string
      required:
        - outcome
      title: RetainResponse
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.RetainResponse
    InsightsResponse:
      description: Insights Component Response
      example:
        cert:
          age_seconds: 33
          approx_ip_geo:
            city: Austin
            country_code: US
            lat: 30.4548
            lon: -97.7664
            postal_code: '78729'
            state: TX
            time_zone: America/Chicago
          browser:
            full: Chrome 95.0.4638.69
            name: Chrome
            version:
              full: 95.0.4638.69
              major: '95'
              minor: '0'
              patch: '4638.69'
          created_at: '2021-11-12T22:06:44Z'
          domain: example.com
          event_duration_ms: 21110
          expires_at: '2021-11-15T22:06:44Z'
          form_input_method:
            - typing
            - autofill
          ip: 8.8.8.8
          is_framed: true
          is_mobile: false
          kpm: 68.2314
          operating_system:
            full: Mac OS X 10.15.7
            name: Mac OS X
            version:
              full: 10.15.7
              major: '10'
              minor: '15'
              patch: '7'
          page_id: 5d8ce3c9502b426f77001ae7
          page_url: https://www.example.com/contact.html
          parent_page_url: https://www.example.com/index.html
          user_agent: >-
            Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36
            (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36
          wpm: 77.1234
        fingerprints:
          matching:
            - c4a8e7fe184993964ae81380e91579015306838a
            - d511850d569bcd7802c30f54de34bb9f2b31eede
          non_matching:
            - d511850d569bcd7802c30f54de34bb9f2b31eed1
        is_masked: false
        outcome: success
        scans:
          forbidden_found:
            - Enim sit amet venenatis
          forbidden_not_found:
            - Est velit egestas
          required_found:
            - lorem ipsum dolor
          required_not_found:
            - Ad qui aperiri
        warnings: []
      properties:
        cert:
          $ref: '#/components/schemas/DataServiceCert'
        fingerprints:
          $ref: '#/components/schemas/Fingerprints'
        is_masked:
          description: A boolean indicating whether the certificate is masked
          type: boolean
        outcome:
          default: success
          description: >
            The result of the attempt to verify consent. Success indicates that
            the request did not generate any warnings related to consent
            verification. Failure indicates that the requests generated warnings
            because no fingerprints matched, forbidden scan terms were found or
            required scan terms were missing. Error indicates that the request
            was not successfull and the request should be reviewed and
            potentially retried.
          enum:
            - success
            - failure
            - error
          type: string
        reason:
          description: |
            Provides an explanation for failure or error.

            Only used for `outcome` of `failure` or `error`.
          type: string
        scans:
          $ref: '#/components/schemas/PageScans'
        warnings:
          description: |2
              An array of strings indicating possible issues with the certificate

              * `none of the provided fingerprints match`: No fingerprints matched.
              * `string not found in snapshot`: A required page scan text was not found.
              * `string found in snapshot`: A forbidden page scan text was found.
          items:
            enum:
              - none of the provided fingerprints match
              - string not found in snapshot
              - string found in snapshot
            type: string
          type: array
      required:
        - outcome
        - cert
        - is_masked
        - scans
        - fingerprints
      title: InsightsResponse
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.InsightsResponse
    Fingerprints:
      example:
        matching:
          - c4a8e7fe184993964ae81380e91579015306838a
          - d511850d569bcd7802c30f54de34bb9f2b31eede
        non_matching:
          - d511850d569bcd7802c30f54de34bb9f2b31eed1
      properties:
        matching:
          description: >-
            Requested fingerprints that match fingerprints collected with the
            certificate
          items:
            type: string
          type: array
        not_matching:
          description: >-
            Fingerprints that do not match fingerprints collected with the
            certificate
          items:
            type: string
          type: array
      title: Fingerprints
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.ClaimFingerprints
    PageScans:
      example:
        forbidden_found:
          - Enim sit amet venenatis
        forbidden_not_found:
          - Est velit egestas
        required_found:
          - lorem ipsum dolor
        required_not_found:
          - Ad qui aperiri
      properties:
        forbidden_found:
          description: Requested required text found on page
          items:
            type: string
          type: array
        forbidden_not_found:
          description: Requested required text not found on page
          items:
            type: string
          type: array
        required_found:
          description: Requested required text found on page
          items:
            type: string
          type: array
        required_not_found:
          description: Requested required text not found on page
          items:
            type: string
          type: array
      required:
        - required_found
        - required_not_found
        - forbidden_found
        - forbidden_not_found
      title: PageScans
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.ClaimPageScans
    WebCertificate:
      example:
        age_seconds: 33
        approx_ip_geo:
          city: Austin
          country_code: US
          lat: 30.4548
          lon: -97.7664
          postal_code: '78729'
          state: TX
          time_zone: America/Chicago
        browser:
          full: Chrome 95.0.4638.69
          name: Chrome
          version:
            full: 95.0.4638.69
            major: '95'
            minor: '0'
            patch: '4638.69'
        cert_id: ddbb5429ca0063f857197df1a4638665bc143eee
        created_at: '2021-11-12T22:06:44Z'
        domain: example.com
        event_duration_ms: 21110
        expires_at: '2021-11-15T22:06:44Z'
        form_input_method:
          - typing
          - autofill
        ip: 8.8.8.8
        is_framed: true
        is_mobile: false
        kpm: 68.2314
        operating_system:
          full: Mac OS X 10.15.7
          name: Mac OS X
          version:
            full: 10.15.7
            major: '10'
            minor: '15'
            patch: '7'
        page_id: 5d8ce3c9502b426f77001ae7
        page_url: https://www.example.com/contact.html
        parent_page_url: https://www.example.com/index.html
        user_agent: >-
          Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36
          (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36
        wpm: 77.1234
      properties:
        age_seconds:
          description: >-
            Number of seconds since the last user interaction with the
            certificate
          type: integer
        approx_ip_geo:
          description: Approximate geolocation based on IP
          properties:
            city:
              description: City Name
              nullable: true
              type: string
            country_code:
              description: Country Code
              type: string
            lat:
              description: Latitude
              type: number
            lon:
              description: Longitude
              type: number
            postal_code:
              description: Mailing address postal code
              type: string
            state:
              description: State/Province or Political Subdivision abbreviation
              type: string
            time_zone:
              description: Timezone name
              type: string
          type: object
        browser:
          description: Browser parsed from the user-agent, when known
          properties:
            full:
              description: >-
                A human-friendly version of the browser parsed from the
                user-agent
              type: string
            name:
              description: Browser name
              type: string
            version:
              description: Browser version
              properties:
                full:
                  description: A String containing the version
                  type: string
                major:
                  description: A String containing the major version
                  type: string
                minor:
                  description: A String containing the minor version
                  type: string
                patch:
                  description: A String containing the patch version
                  type: string
              type: object
          type: object
        cert_id:
          description: Certificate ID
          type: string
        created_at:
          description: >-
            The UTC ISO8601 formatted date and time when the TrustedForm script
            was loaded
          format: date-time
          type: string
        domain:
          description: The domain of the page url
          type: string
        event_duration_ms:
          description: >-
            The time in milliseconds between when the script was loaded and when
            the most recent event was received
          type: integer
        expires_at:
          description: >-
            The UTC ISO8601 formatted date and time when the claim period for
            the certificate will expire
          format: date-time
          type: string
        form_input_method:
          description: |2
              The detected input method or methods the consumer used to fill out the form

              * `autofill`: The form was filled out using browser autofill.
              * `paste`: The form was filled out pasting text.
              * `typing`: The form was filled out typing.
          items:
            enum:
              - autofill
              - paste
              - typing
            type: string
          type: array
          uniqueItems: true
        ip:
          description: The consumer's public IP address
          type: string
        is_framed:
          description: A boolean indicating that the form was displayed within an iframe
          type: boolean
        is_mobile:
          description: >-
            A boolean indicating that the form was filled out on a mobile device
            or tablet, based on user-agent
          type: boolean
        kpm:
          description: Approximate calculated words per minute
          type: number
        operating_system:
          description: Operating system information parsed from the user-agent, when known
          properties:
            full:
              description: >-
                A human-friendly version of the operating system information
                parsed from the user-agent
              type: string
            name:
              description: Operating system name
              type: string
            version:
              description: Operating system version
              properties:
                full:
                  description: A String containing the version
                  type: string
                major:
                  description: A String containing the major version
                  type: string
                minor:
                  description: A String containing the minor version
                  type: string
                patch:
                  description: A String containing the patch version
                  type: string
              type: object
          type: object
        page_id:
          description: The account based unique page id
          type: string
        page_url:
          description: The URL of the page hosting the TrustedForm script
          format: url
          type: string
        parent_page_url:
          description: The parent URL of the page hosting the TrustedForm script, if framed
          format: url
          nullable: true
          type: string
        user_agent:
          description: The consumer's browser user-agent
          type: string
        wpm:
          description: Approximate calculated key presses per minute
          type: number
      required:
        - age_seconds
        - approx_ip_geo
        - browser
        - cert_id
        - created_at
        - domain
        - expires_at
        - event_duration_ms
        - is_framed
        - form_input_method
        - ip
        - kpm
        - is_mobile
        - operating_system
        - page_id
        - page_url
        - parent_page_url
        - user_agent
        - wpm
      title: WebCertificate
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.WebCertV3
    DataServiceCert:
      example:
        age_seconds: 33
        approx_ip_geo:
          city: Austin
          country_code: US
          lat: 30.4548
          lon: -97.7664
          postal_code: '78729'
          state: TX
          time_zone: America/Chicago
        browser:
          full: Chrome 95.0.4638.69
          name: Chrome
          version:
            full: 95.0.4638.69
            major: '95'
            minor: '0'
            patch: '4638.69'
        created_at: '2021-11-12T22:06:44Z'
        domain: example.com
        event_duration_ms: 21110
        expires_at: '2021-11-15T22:06:44Z'
        form_input_method:
          - typing
          - autofill
        ip: 8.8.8.8
        is_framed: true
        is_mobile: false
        kpm: 68.2314
        operating_system:
          full: Mac OS X 10.15.7
          name: Mac OS X
          version:
            full: 10.15.7
            major: '10'
            minor: '15'
            patch: '7'
        page_id: 5d8ce3c9502b426f77001ae7
        page_url: https://www.example.com/contact.html
        parent_page_url: https://www.example.com/index.html
        user_agent: >-
          Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36
          (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36
        wpm: 77.1234
      properties:
        age_seconds:
          description: >-
            Number of seconds since the last user interaction with the
            certificate
          type: integer
        approx_ip_geo:
          description: Approximate geolocation based on IP
          nullable: true
          properties:
            city:
              description: City Name
              nullable: true
              type: string
            country_code:
              description: Country Code
              nullable: true
              type: string
            lat:
              description: Latitude
              nullable: true
              type: number
            lon:
              description: Longitude
              nullable: true
              type: number
            postal_code:
              description: Mailing address postal code
              nullable: true
              type: string
            state:
              description: State/Province or Political Subdivision abbreviation
              nullable: true
              type: string
            time_zone:
              description: Timezone name
              nullable: true
              type: string
          type: object
        browser:
          description: Browser parsed from the user-agent, when known
          nullable: true
          properties:
            full:
              description: >-
                A human-friendly version of the browser parsed from the
                user-agent
              type: string
            name:
              description: Browser name
              type: string
            version:
              description: Browser version
              properties:
                full:
                  description: A String containing the version
                  type: string
                major:
                  description: A String containing the major version
                  type: string
                minor:
                  description: A String containing the minor version
                  type: string
                patch:
                  description: A String containing the patch version
                  type: string
              type: object
          type: object
        created_at:
          description: >-
            The UTC ISO8601 formatted date and time when the TrustedForm script
            was loaded
          format: date-time
          type: string
        domain:
          description: The domain of the page url
          nullable: true
          type: string
        event_duration_ms:
          description: >-
            The time in milliseconds between when the script was loaded and when
            the most recent event was received
          nullable: true
          type: integer
        expires_at:
          description: >-
            The UTC ISO8601 formatted date and time when the claim period for
            the certificate will expire
          format: date-time
          type: string
        form_input_method:
          description: |2
              The detected input method or methods the consumer used to fill out the form

              * `autofill`: The form was filled out using browser autofill.
              * `paste`: The form was filled out pasting text.
              * `typing`: The form was filled out typing.
          items:
            enum:
              - autofill
              - paste
              - typing
            type: string
          nullable: true
          type: array
          uniqueItems: true
        ip:
          description: The consumer's public IP address
          nullable: true
          type: string
        is_framed:
          description: A boolean indicating that the form was displayed within an iframe
          nullable: true
          type: boolean
        is_mobile:
          description: >-
            A boolean indicating that the form was filled out on a mobile device
            or tablet, based on user-agent
          nullable: true
          type: boolean
        kpm:
          description: Approximate calculated words per minute
          nullable: true
          type: number
        operating_system:
          description: Operating system information parsed from the user-agent, when known
          nullable: true
          properties:
            full:
              description: >-
                A human-friendly version of the operating system information
                parsed from the user-agent
              type: string
            name:
              description: Operating system name
              type: string
            version:
              description: Operating system version
              properties:
                full:
                  description: A String containing the version
                  type: string
                major:
                  description: A String containing the major version
                  type: string
                minor:
                  description: A String containing the minor version
                  type: string
                patch:
                  description: A String containing the patch version
                  type: string
              type: object
          type: object
        page_id:
          description: The account based unique page id
          nullable: true
          type: string
        page_url:
          description: The URL of the page hosting the TrustedForm script
          format: url
          nullable: true
          type: string
        parent_page_url:
          description: The parent URL of the page hosting the TrustedForm script, if framed
          format: url
          nullable: true
          type: string
        user_agent:
          description: The consumer's browser user-agent
          nullable: true
          type: string
        wpm:
          description: Approximate calculated key presses per minute
          nullable: true
          type: number
      required:
        - age_seconds
        - approx_ip_geo
        - browser
        - created_at
        - domain
        - expires_at
        - event_duration_ms
        - is_framed
        - form_input_method
        - ip
        - kpm
        - is_mobile
        - operating_system
        - page_id
        - page_url
        - parent_page_url
        - user_agent
        - wpm
      title: DataServiceCert
      type: object
      x-struct: Elixir.ClaimerWeb.Schemas.DataServiceCert

````