# GetAttestationRecord

POST https://api-demo.brij.fi/brij.core.v1.partner.Service/GetAttestationRecord
Content-Type: application/json

Retrieve a specific attestation record by its ID. This returns the full attestation details including verification
 status and linked data.

Reference: https://docs.brij.fi/api/brij-partner-api/brij-core-v-1-partner-service-get-attestation-record

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: partner-api
  version: 1.0.0
paths:
  /brij.core.v1.partner.Service/GetAttestationRecord:
    post:
      operationId: brij-core-v-1-partner-service-get-attestation-record
      summary: GetAttestationRecord
      description: >-
        Retrieve a specific attestation record by its ID. This returns the full
        attestation details including verification
         status and linked data.
      tags:
        - ''
      parameters:
        - name: X-API-Key
          in: header
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/brij.core.v1.partner.GetAttestationRecordResponse
      requestBody:
        content:
          application/json:
            schema:
              $ref: >-
                #/components/schemas/brij.core.v1.partner.GetAttestationRecordRequest
servers:
  - url: https://api-demo.brij.fi
  - url: https://api.brij.fi
components:
  schemas:
    brij.core.v1.partner.GetAttestationRecordRequest:
      type: object
      properties:
        attestationId:
          type: string
      title: brij.core.v1.partner.GetAttestationRecordRequest
    brij.data.v1.AttestationType:
      type: string
      enum:
        - VALIDATED_EMAIL
        - VALIDATED_PHONE
        - VALIDATED_ID_DOCUMENT
        - LIVENESS_CHECK
        - AML_CHECK
        - TERMS
        - VALIDATED_CRYPTO_WALLET
      description: Attestation types supported by the system
      title: brij.data.v1.AttestationType
    brij.data.v1.AttestationStatus:
      type: string
      enum:
        - WAITING_USER_ACTION
        - IN_PROGRESS
        - COMPLETED
        - FAILED
        - REJECTED
        - EXPIRED
        - REVOKED
      description: Attestation status during lifecycle
      title: brij.data.v1.AttestationStatus
    brij.data.v1.AmlProof:
      type: object
      properties: {}
      description: AML/KYC screening verification proof
      title: brij.data.v1.AmlProof
    BrijDataV1AttestationProof0:
      type: object
      properties:
        amlProof:
          $ref: '#/components/schemas/brij.data.v1.AmlProof'
      required:
        - amlProof
      title: BrijDataV1AttestationProof0
    brij.data.v1.CryptoWallet.Type:
      type: string
      enum:
        - SOLANA
        - BITCOIN
        - ETHEREUM
        - BSC
        - POLYGON
        - ARBITRUM
        - BASE
        - OPTIMISM
        - AVALANCHEC
        - AVALANCHEX
        - TRON
        - TON
      title: brij.data.v1.CryptoWallet.Type
    brij.data.v1.CryptoWalletProof:
      type: object
      properties:
        method:
          type: string
          description: '"signature_verification"'
        walletType:
          $ref: '#/components/schemas/brij.data.v1.CryptoWallet.Type'
          description: Type of wallet (SOLANA, etc.)
        challengeMessage:
          type: string
          description: The challenge message that was signed
        signature:
          type: string
          description: Base58-encoded signature
      description: Crypto wallet ownership proof (signature-based)
      title: brij.data.v1.CryptoWalletProof
    BrijDataV1AttestationProof1:
      type: object
      properties:
        cryptoWalletProof:
          $ref: '#/components/schemas/brij.data.v1.CryptoWalletProof'
      required:
        - cryptoWalletProof
      title: BrijDataV1AttestationProof1
    brij.data.v1.EmailProof:
      type: object
      properties:
        method:
          type: string
          description: '"otp"'
        otpHash:
          type: string
          description: SHA-256 hash of the OTP code
      description: Email verification proof (OTP-based)
      title: brij.data.v1.EmailProof
    BrijDataV1AttestationProof2:
      type: object
      properties:
        emailProof:
          $ref: '#/components/schemas/brij.data.v1.EmailProof'
      required:
        - emailProof
      title: BrijDataV1AttestationProof2
    brij.data.v1.IdDocumentProof:
      type: object
      properties: {}
      description: ID document verification proof
      title: brij.data.v1.IdDocumentProof
    BrijDataV1AttestationProof3:
      type: object
      properties:
        idDocumentProof:
          $ref: '#/components/schemas/brij.data.v1.IdDocumentProof'
      required:
        - idDocumentProof
      title: BrijDataV1AttestationProof3
    brij.data.v1.LivenessProof:
      type: object
      properties:
        method:
          type: string
          description: '"video", "photos"'
      description: Liveness check verification proof
      title: brij.data.v1.LivenessProof
    BrijDataV1AttestationProof4:
      type: object
      properties:
        livenessProof:
          $ref: '#/components/schemas/brij.data.v1.LivenessProof'
      required:
        - livenessProof
      title: BrijDataV1AttestationProof4
    brij.data.v1.PhoneProof:
      type: object
      properties:
        method:
          type: string
          description: '"sms_otp"'
        otpHash:
          type: string
          description: SHA-256 hash of the OTP code
      description: Phone verification proof (SMS OTP-based)
      title: brij.data.v1.PhoneProof
    BrijDataV1AttestationProof5:
      type: object
      properties:
        phoneProof:
          $ref: '#/components/schemas/brij.data.v1.PhoneProof'
      required:
        - phoneProof
      title: BrijDataV1AttestationProof5
    brij.data.v1.TermsProof:
      type: object
      properties:
        acceptanceCode:
          type: string
          description: Optional acceptance code from partner's dynamic terms flow
      description: Terms & Conditions acceptance proof
      title: brij.data.v1.TermsProof
    BrijDataV1AttestationProof6:
      type: object
      properties:
        termsProof:
          $ref: '#/components/schemas/brij.data.v1.TermsProof'
      required:
        - termsProof
      title: BrijDataV1AttestationProof6
    brij.data.v1.AttestationProof:
      oneOf:
        - $ref: '#/components/schemas/BrijDataV1AttestationProof0'
        - $ref: '#/components/schemas/BrijDataV1AttestationProof1'
        - $ref: '#/components/schemas/BrijDataV1AttestationProof2'
        - $ref: '#/components/schemas/BrijDataV1AttestationProof3'
        - $ref: '#/components/schemas/BrijDataV1AttestationProof4'
        - $ref: '#/components/schemas/BrijDataV1AttestationProof5'
        - $ref: '#/components/schemas/BrijDataV1AttestationProof6'
      description: >-
        AttestationProof contains cryptographic proof of customer data
        verification
         Stored as protobuf-serialized BYTEA in attestations.proof_data column
         The signature is computed over the hash of this serialized message and stored separately
      title: brij.data.v1.AttestationProof
    google.protobuf.Timestamp:
      type: string
      format: date-time
      description: >-
        A Timestamp represents a point in time independent of any time zone or
        local
         calendar, encoded as a count of seconds and fractions of seconds at
         nanosecond resolution. The count is relative to an epoch at UTC midnight on
         January 1, 1970, in the proleptic Gregorian calendar which extends the
         Gregorian calendar backwards to year one.

         All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
         second table is needed for interpretation, using a [24-hour linear
         smear](https://developers.google.com/time/smear).

         The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
         restricting to that range, we ensure that we can convert to and from [RFC
         3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

         # Examples

         Example 1: Compute Timestamp from POSIX `time()`.

             Timestamp timestamp;
             timestamp.set_seconds(time(NULL));
             timestamp.set_nanos(0);

         Example 2: Compute Timestamp from POSIX `gettimeofday()`.

             struct timeval tv;
             gettimeofday(&tv, NULL);

             Timestamp timestamp;
             timestamp.set_seconds(tv.tv_sec);
             timestamp.set_nanos(tv.tv_usec * 1000);

         Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

             FILETIME ft;
             GetSystemTimeAsFileTime(&ft);
             UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

             // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
             // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
             Timestamp timestamp;
             timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
             timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

         Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

             long millis = System.currentTimeMillis();

             Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
                 .setNanos((int) ((millis % 1000) * 1000000)).build();

         Example 5: Compute Timestamp from Java `Instant.now()`.

             Instant now = Instant.now();

             Timestamp timestamp =
                 Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                     .setNanos(now.getNano()).build();

         Example 6: Compute Timestamp from current time in Python.

             timestamp = Timestamp()
             timestamp.GetCurrentTime()

         # JSON Mapping

         In JSON format, the Timestamp type is encoded as a string in the
         [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
         format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
         where {year} is always expressed using four digits while {month}, {day},
         {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
         seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
         are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
         is required. A proto3 JSON serializer should always use UTC (as indicated by
         "Z") when printing the Timestamp type and a proto3 JSON parser should be
         able to accept both UTC and other timezones (as indicated by an offset).

         For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
         01:30 UTC on January 15, 2017.

         In JavaScript, one can convert a Date object to this format using the
         standard
         [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
         method. In Python, a standard `datetime.datetime` object can be converted
         to this format using
         [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
         the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
         the Joda Time's [`ISODateTimeFormat.dateTime()`](
         http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
         ) to obtain a formatter capable of generating timestamps in this format.
      title: google.protobuf.Timestamp
    brij.core.v1.partner.AttestationRecord:
      type: object
      properties:
        id:
          type: string
        type:
          $ref: '#/components/schemas/brij.data.v1.AttestationType'
        status:
          $ref: '#/components/schemas/brij.data.v1.AttestationStatus'
        linkedDataIds:
          type: array
          items:
            type: string
        rawProof:
          type: string
          format: byte
        signature:
          type: string
          format: byte
        verifierPublicKey:
          type: string
        proof:
          $ref: '#/components/schemas/brij.data.v1.AttestationProof'
        verifiedAt:
          $ref: '#/components/schemas/google.protobuf.Timestamp'
      description: Partner-specific attestation record
      title: brij.core.v1.partner.AttestationRecord
    brij.core.v1.partner.GetAttestationRecordResponse:
      type: object
      properties:
        attestationRecord:
          $ref: '#/components/schemas/brij.core.v1.partner.AttestationRecord'
      title: brij.core.v1.partner.GetAttestationRecordResponse
  securitySchemes:
    PartnerApiKey:
      type: apiKey
      in: header
      name: X-API-Key

```

## SDK Code Examples

```python
import requests

url = "https://api-demo.brij.fi/brij.core.v1.partner.Service/GetAttestationRecord"

payload = {}
headers = {
    "X-API-Key": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api-demo.brij.fi/brij.core.v1.partner.Service/GetAttestationRecord';
const options = {
  method: 'POST',
  headers: {'X-API-Key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api-demo.brij.fi/brij.core.v1.partner.Service/GetAttestationRecord"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-API-Key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api-demo.brij.fi/brij.core.v1.partner.Service/GetAttestationRecord")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["X-API-Key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api-demo.brij.fi/brij.core.v1.partner.Service/GetAttestationRecord")
  .header("X-API-Key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api-demo.brij.fi/brij.core.v1.partner.Service/GetAttestationRecord', [
  'body' => '{}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-API-Key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api-demo.brij.fi/brij.core.v1.partner.Service/GetAttestationRecord");
var request = new RestRequest(Method.POST);
request.AddHeader("X-API-Key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "X-API-Key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api-demo.brij.fi/brij.core.v1.partner.Service/GetAttestationRecord")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```