> ## 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 /v2/userinfo`
* REST API: `GET /connect/v2/verifications/{id}/userinfo`

## Provenance (shape)

```ts theme={null}
type ProvenanceShape = {
  presentation: {
    credentials: Array<{
      claims: Record<string, unknown> // the source's own response, as received (match connections too)
      evidence?: {
        token?: Record<string, unknown>
        names?: string // semicolon-delimited list of keys present under token
      }
    }>
  }
  _metadata: {
    provider_id: string
    connection_id?: string
    credential_id?: string
    connection_instance_id: string
    verification_id: string
    verified_at?: string
    status: string
    error?: { code: string; message?: string } // only when the session ended with an error (e.g. loa_insufficient)
  }
}
```

The connection that produced the credential is identified by `provider_id`, `connection_id`, `credential_id`, and `connection_instance_id` inside `provenance._metadata`. These are not top-level userinfo fields. New sessions include all four. Older sessions created before identity snapshots may omit `connection_id` or `credential_id` until they expire.

<Note>
  Learn more: <a href="/v2/guides/verifications/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 {
      credentials: Credential[]
    }

    export interface Credential {
      claims: Record<string, unknown> // the source's own response, as received
      evidence?: Evidence // may or may not be present
    }

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

    export interface Metadata {
      provider_id: string
      connection_id?: string
      credential_id?: string
      connection_instance_id: string
      verification_id: string
      verified_at?: string // ISO8601
      status: string // session status at read time (e.g., completed)
      error?: { code: string; message?: string }
    }
    ```
  </Tab>

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

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

    type Presentation struct {
      Credentials []Credential `json:"credentials"`
    }

    type Credential struct {
      Claims   map[string]any `json:"claims"`             // the source's own response, as received
      Evidence *Evidence      `json:"evidence,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 MetadataError struct {
      Code    string `json:"code"`
      Message string `json:"message,omitempty"`
    }

    type Metadata struct {
      ProviderID string `json:"provider_id"`
      ConnectionID string `json:"connection_id,omitempty"`
      CredentialID string `json:"credential_id,omitempty"`
      ConnectionInstanceID string `json:"connection_instance_id"`
      VerificationID string         `json:"verification_id"`
      VerifiedAt     string         `json:"verified_at,omitempty"`
      Status         string         `json:"status"`
      Error          *MetadataError `json:"error,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("credentials")] public List<Credential> Credentials { get; set; } = new();
    }

    public class Credential {
      [JsonPropertyName("claims")] public Dictionary<string, object>? Claims { get; set; } // the source's own response, as received
      [JsonPropertyName("evidence")] public Evidence? Evidence { get; set; } // may or may not be present
    }

    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 MetadataError {
      [JsonPropertyName("code")] public string Code { get; set; } = default!;
      [JsonPropertyName("message")] public string? Message { get; set; }
    }

    public class Metadata {
      [JsonPropertyName("provider_id")] public string ProviderId { get; set; } = default!;
      [JsonPropertyName("connection_id")] public string? ConnectionId { get; set; }
      [JsonPropertyName("credential_id")] public string? CredentialId { get; set; }
      [JsonPropertyName("connection_instance_id")] public string ConnectionInstanceId { get; set; } = default!;
      [JsonPropertyName("verification_id")] public string VerificationId { get; set; } = default!;
      [JsonPropertyName("verified_at")] public string? VerifiedAt { get; set; }
      [JsonPropertyName("status")] public string Status { get; set; } = default!;
      [JsonPropertyName("error")] public MetadataError? Error { 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 List<Credential> credentials;
    }

    public class Credential {
      public Map<String, Object> claims;    // the source's own response, as received
      public Evidence evidence;             // May or may not be present
    }

    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 MetadataError {
      public String code;
      public String message;
    }

    public class Metadata {
      public String provider_id;
      public String connection_id; // optional for older sessions
      public String credential_id; // optional for older sessions
      public String connection_instance_id;
      public String verification_id;
      public String verified_at; // ISO8601
      public String status;      // session status at read time
      public MetadataError error; // only when the session ended with an error
    }
    ```
  </Tab>
</Tabs>

## Notes

* `claims` keeps the source's native field names and can vary by connection. Treat unknown fields as opaque.
* `evidence` shape varies by provider. Most use `{ token, names }`. Wallet credentials (mdoc, Verifiable Presentation) place fields such as `issuerAuth` or `vpClaims` directly on `evidence`. See [Evidence & Data Integrity](/v2/guides/verifications/evidence).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.