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

# Provenance

> Provenance shape and copy‑paste types for /userinfo responses.

**Scope**

* OIDC: `GET /userinfo`
* REST API: `GET /verifications/{id}/userinfo`

## Provenance (shape)

```ts theme={null}
type ProvenanceShape = {
  presentation: {
    channel?: {
      type: 'centralized_idp' | 'chip_based' | 'wallet' | string
      transport: 'internet' | 'nfc' | 'ble' | 'qr_code' | string
    }
    credentials: Array<{
      type: string // providerId used when starting the verification (e.g., smartid, bankidse)
      issuer?: { id: string; authority_name?: string; is_government?: boolean }
      claims: Record<string, unknown>
      evidence?: {
        token?: Record<string, unknown>
        names?: string // semicolon-delimited list of keys present under token
      }
    }>
  }
  _metadata: { verification_id: string; verified_at?: string }
}
```

<Note>
  Learn more: <a href="/guides/concepts/return-data-model#what-%E2%80%9Cprovenance%E2%80%9D-means">Provenance</a>
</Note>

## Copy & Paste Types

<Tabs>
  <Tab title="TypeScript">
    ```ts theme={null}
    export interface Proof {
      presentation: Presentation
      _metadata: Metadata
    }

    export interface Presentation {
      channel?: Channel
      credentials: Credential[]
    }

    export interface Channel {
      type: 'centralized_idp' | 'chip_based' | 'wallet' | string
      transport: 'internet' | 'nfc' | 'ble' | 'qr_code' | string
    }

    export interface Credential {
      type: string // providerId used when starting the verification (e.g., smartid, bankidse)
      issuer?: Issuer
      claims: Record<string, unknown>
      evidence?: Evidence // may or may not be present
    }

    export interface Issuer {
      id: string
      authority_name?: string
      is_government?: boolean
    }

    export interface Evidence {
      token?: Record<string, unknown>
      names?: string // semicolon-delimited list of keys under token
    }

    export interface Metadata {
      verification_id: string
      verified_at?: string // ISO8601
    }
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    package models

    type Proof struct {
      Presentation Presentation `json:"presentation"`
      Metadata     Metadata     `json:"_metadata"`
    }

    type Presentation struct {
      Channel     *Channel     `json:"channel,omitempty"`
      Credentials []Credential `json:"credentials"`
    }

    type Channel struct {
      Type      string `json:"type"`
      Transport string `json:"transport"`
    }

    type Credential struct {
      Type     string                 `json:"type"` // providerId used when starting the verification (e.g., smartid, bankidse)
      Issuer   *Issuer                `json:"issuer,omitempty"`
      Claims   map[string]any         `json:"claims"`
      Evidence *Evidence              `json:"evidence,omitempty"`
    }

    type Issuer struct {
      ID            string `json:"id"`
      AuthorityName string `json:"authority_name,omitempty"`
      IsGovernment  *bool  `json:"is_government,omitempty"`
    }

    type Evidence struct {
      Token map[string]any `json:"token,omitempty"` // provider-supplied key/value pairs
      Names string         `json:"names,omitempty"` // semicolon-delimited key list
    }

    type Metadata struct {
      VerificationID string `json:"verification_id"`
      VerifiedAt     string `json:"verified_at,omitempty"`
    }
    ```
  </Tab>

  <Tab title="C#">
    ```csharp theme={null}
    using System.Collections.Generic;
    using System.Text.Json.Serialization;

    public class Proof {
      [JsonPropertyName("presentation")] public Presentation Presentation { get; set; } = default!;
      [JsonPropertyName("_metadata")] public Metadata Metadata { get; set; } = default!;
    }

    public class Presentation {
      [JsonPropertyName("channel")] public Channel? Channel { get; set; }
      [JsonPropertyName("credentials")] public List<Credential> Credentials { get; set; } = new();
    }

    public class Channel {
      [JsonPropertyName("type")] public string? Type { get; set; }
      [JsonPropertyName("transport")] public string? Transport { get; set; }
    }

    public class Credential {
      [JsonPropertyName("type")] public string Type { get; set; } = default!; // providerId used when starting the verification (e.g., smartid, bankidse)
      [JsonPropertyName("issuer")] public Issuer? Issuer { get; set; }
      [JsonPropertyName("claims")] public Dictionary<string, object>? Claims { get; set; }
      [JsonPropertyName("evidence")] public Evidence? Evidence { get; set; } // may or may not be present
    }

    public class Issuer {
      [JsonPropertyName("id")] public string Id { get; set; } = default!;
      [JsonPropertyName("authority_name")] public string? AuthorityName { get; set; }
      [JsonPropertyName("is_government")] public bool? IsGovernment { get; set; }
    }

    public class Evidence {
      [JsonPropertyName("token")] public Dictionary<string, object>? Token { get; set; } // provider-supplied key/value pairs
      [JsonPropertyName("names")] public string? Names { get; set; } // semicolon-delimited key list
    }

    public class Metadata {
      [JsonPropertyName("verification_id")] public string VerificationId { get; set; } = default!;
      [JsonPropertyName("verified_at")] public string? VerifiedAt { get; set; }
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    import java.util.List;
    import java.util.Map;

    public class Proof {
      public Presentation presentation;
      public Metadata _metadata;
    }

    public class Presentation {
      public Channel channel;
      public List<Credential> credentials;
    }

    public class Channel {
      public String type;      // centralized_idp | chip_based | wallet | string
      public String transport; // internet | nfc | ble | qr_code | string
    }

    public class Credential {
      public String type; // providerId used when starting the verification (e.g., smartid, bankidse)
      public Issuer issuer;
      public Map<String, Object> claims;    // Raw upstream provider claims
      public Evidence evidence;             // May or may not be present
    }

    public class Issuer {
      public String id;                // e.g., urn:hopae:issuer:ee:smartid
      public String authority_name;
      public Boolean is_government;
    }

    public class Evidence {
      public Map<String, Object> token; // Provider-supplied key/value pairs
      public String names; // Semicolon-delimited list of keys under token
    }

    public class Metadata {
      public String verification_id;
      public String verified_at; // ISO8601
    }
    ```
  </Tab>
</Tabs>

## Notes

* Issuer and claims can vary by credential type; treat unknown fields as opaque.