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

# Get test snapshot detail for an evidence row

> Retrieves the rich detail for a single VANTA_TEST_SNAPSHOT evidence row
attached to an information request. The response includes test-level
metadata (description, integrations, SLA), the raw test data captured
at snapshot time, and the resources that were excluded from the test
(out-of-scope resources).

For structured snapshots, the `rawTestData` array contains one row per
resource the test ran against; each row carries `resourceId`,
`resourceType`, and the raw JSON for that resource.

For unstructured snapshots, the `rawTestData` array contains a single
row with `resourceId` and `resourceType` set to `null` and `rawJson`
containing the entire test-run JSON blob.

The `outOfScopeResources` field lists resources excluded at the test
level (customer-disabled) and the framework level (segment
configuration). Empty exclusion groups are filtered out.

The `apiRequests` array contains the HTTP requests captured during API
introspection tests. Empty when the test does not perform API
introspection.

Rate limit: 10 requests / minute.



## OpenAPI

````yaml https://spec.speakeasy.com/vanta/vanta/conduct-an-audit-with-code-samples get /audits/{auditId}/information-requests/{requestId}/evidence/{evidenceId}/test-snapshot
openapi: 3.0.0
info:
  title: Conduct an audit
  version: 1.0.0
  description: >-
    The Auditor API lets audit firms conduct audits from a tool outside of
    Vanta. Unlock data syncing with Vanta through this API.


    **Note for Vanta Gov (FedRAMP) customers:** Select `Vanta Gov (FedRAMP)`
    from the server dropdown to issue requests against
    `https://api.vanta-gov.com`. The OAuth token URL shown below defaults to the
    commercial host — replace it with `https://api.vanta-gov.com/oauth/token`.
  termsOfService: https://www.vanta.com/terms
  license:
    name: UNLICENSED
  contact:
    name: API Support
    url: https://help.vanta.com/
    email: support@vanta.com
servers:
  - url: https://api.vanta.com/v1
    description: Vanta (Commercial)
  - url: https://api.vanta-gov.com/v1
    description: Vanta Gov (FedRAMP)
security: []
paths:
  /audits/{auditId}/information-requests/{requestId}/evidence/{evidenceId}/test-snapshot:
    get:
      tags:
        - Audits
      summary: Get test snapshot detail for an evidence row
      description: |-
        Retrieves the rich detail for a single VANTA_TEST_SNAPSHOT evidence row
        attached to an information request. The response includes test-level
        metadata (description, integrations, SLA), the raw test data captured
        at snapshot time, and the resources that were excluded from the test
        (out-of-scope resources).

        For structured snapshots, the `rawTestData` array contains one row per
        resource the test ran against; each row carries `resourceId`,
        `resourceType`, and the raw JSON for that resource.

        For unstructured snapshots, the `rawTestData` array contains a single
        row with `resourceId` and `resourceType` set to `null` and `rawJson`
        containing the entire test-run JSON blob.

        The `outOfScopeResources` field lists resources excluded at the test
        level (customer-disabled) and the framework level (segment
        configuration). Empty exclusion groups are filtered out.

        The `apiRequests` array contains the HTTP requests captured during API
        introspection tests. Empty when the test does not perform API
        introspection.

        Rate limit: 10 requests / minute.
      operationId: GetInformationRequestTestSnapshotEvidenceDetail
      parameters:
        - in: path
          name: auditId
          required: true
          schema:
            type: string
        - in: path
          name: requestId
          required: true
          schema:
            type: string
        - in: path
          name: evidenceId
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Ok
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/VantaTestSnapshotEvidenceDetail'
              examples:
                Example 1:
                  value:
                    testId: test.okta.account-creation
                    testName: Okta user provisioning test
                    description: Verify Okta user accounts are created via SSO.
                    evaluationCriteria: >-
                      Confirms that all human user accounts in Okta were
                      provisioned via the SSO workflow.
                    integrations:
                      - integrationId: okta
                        displayName: Okta
                    slaRemediation:
                      id: sla-30d
                      settings:
                        numericValue: 30
                        unit: DAYS
                    rawTestData:
                      - resourceId: 6890e473dce1da5d8406f700
                        resourceType: OktaUser
                        rawJson:
                          id: 6890e473dce1da5d8406f700
                          status: ACTIVE
                    outOfScopeResources:
                      testLevel:
                        - reason: Disabled by customer
                          entities:
                            - id: 6890e473dce1da5d8406f701
                              displayName: service-account@example.com
                      frameworkLevel: []
                    apiRequests:
                      - id: 6890e473dce1da5d8406f702
                        resourceType: OktaUser
                        resourceTypeDisplayName: Okta User
                        requestMethod: GET
                        url: https://dev-123456.okta.com/api/v1/users
                        responseCode: 200
                        timestamp: '2025-01-15T10:30:00.000Z'
                        dataTooLarge: false
      security:
        - bearerAuth: []
      x-codeSamples:
        - lang: typescript
          label: GetInformationRequestTestSnapshotEvidenceDetail
          source: |-
            import { Vanta } from "vanta-auditor-api-sdk";

            const vanta = new Vanta({
              bearerAuth: process.env["VANTA_BEARER_AUTH"] ?? "",
            });

            async function run() {
              const result = await vanta.audits.getInformationRequestTestSnapshotEvidenceDetail({
                auditId: "<id>",
                requestId: "<id>",
                evidenceId: "<id>",
              });

              console.log(result);
            }

            run();
        - lang: java
          label: GetInformationRequestTestSnapshotEvidenceDetail
          source: >-
            package hello.world;


            import com.vanta.vanta_auditor_api.Vanta;

            import
            com.vanta.vanta_auditor_api.models.operations.GetInformationRequestTestSnapshotEvidenceDetailResponse;

            import java.lang.Exception;


            public class Application {

                public static void main(String[] args) throws Exception {

                    Vanta sdk = Vanta.builder()
                            .bearerAuth(System.getenv().getOrDefault("BEARER_AUTH", ""))
                        .build();

                    GetInformationRequestTestSnapshotEvidenceDetailResponse res = sdk.audits().getInformationRequestTestSnapshotEvidenceDetail()
                            .auditId("<id>")
                            .requestId("<id>")
                            .evidenceId("<id>")
                            .call();

                    if (res.vantaTestSnapshotEvidenceDetail().isPresent()) {
                        System.out.println(res.vantaTestSnapshotEvidenceDetail().get());
                    }
                }
            }
components:
  schemas:
    VantaTestSnapshotEvidenceDetail:
      description: |-
        Detail response for a captured automated-test snapshot evidence row.

        Combines the test-level metadata (description, integrations, SLA
        remediation) with a uniform raw-data array so external clients see the
        same shape regardless of whether the snapshot was structured or
        unstructured.
      properties:
        testId:
          type: string
          description: The unique identifier for the test in Vanta's system.
        testName:
          type: string
          description: The display name of the test.
        description:
          type: string
          description: A short description of what the test checks.
        evaluationCriteria:
          type: string
          nullable: true
          description: Longer-form, formatted description of the test. Null when unset.
        integrations:
          items:
            $ref: '#/components/schemas/VantaTestSnapshotIntegration'
          type: array
          description: Integrations whose data feeds the test.
        slaRemediation:
          allOf:
            - $ref: '#/components/schemas/VantaTestSnapshotSlaRemediation'
          nullable: true
          description: >-
            SLA remediation policy attached to the test, or null when no SLA is
            set.
        rawTestData:
          items:
            $ref: '#/components/schemas/VantaTestSnapshotRawTestDataRow'
          type: array
          description: Raw test data captured at snapshot time.
        outOfScopeResources:
          $ref: '#/components/schemas/VantaTestSnapshotOutOfScopeResources'
          description: |-
            Resources excluded from the test at snapshot time. Absent when the
            snapshot data could not be loaded; clients should treat a missing
            field as "unknown" rather than "nothing excluded".
        apiRequests:
          items:
            $ref: '#/components/schemas/VantaTestSnapshotApiRequest'
          type: array
          description: |-
            API requests captured during the test run. Absent when the snapshot
            data could not be loaded. Empty array when the test does not perform
            API introspection.
      required:
        - testId
        - testName
        - description
        - evaluationCriteria
        - integrations
        - slaRemediation
        - rawTestData
      type: object
      additionalProperties: false
    VantaTestSnapshotIntegration:
      description: Integration metadata for a test, mirroring the Vanta web app.
      properties:
        integrationId:
          type: string
        displayName:
          type: string
      required:
        - integrationId
        - displayName
      type: object
      additionalProperties: false
    VantaTestSnapshotSlaRemediation:
      properties:
        id:
          type: string
        settings:
          allOf:
            - $ref: '#/components/schemas/VantaTestSnapshotSlaRemediationSettings'
          nullable: true
      required:
        - id
        - settings
      type: object
      additionalProperties: false
    VantaTestSnapshotRawTestDataRow:
      description: >-
        One row of raw test data attached to a snapshot.


        For structured snapshots, every row carries the resource refs and the
        raw

        JSON for that resource. For unstructured snapshots, a single row is
        returned

        with `resourceId` and `resourceType` set to `null` and `rawJson`
        containing

        the entire test-run JSON blob.
      properties:
        resourceId:
          type: string
          nullable: true
          description: >-
            Identifier of the underlying resource the row was captured from.
            Null for

            unstructured snapshots, which do not partition by resource.
        resourceType:
          type: string
          nullable: true
          description: |-
            Specific resource kind for the row (e.g. `AwsIamUser`). Null for
            unstructured snapshots.
        rawJson:
          description: >-
            Raw JSON payload as emitted by the test runner. Shape varies by

            `resourceType` for structured snapshots and matches the full
            test-run

            blob for unstructured snapshots.
      required:
        - resourceId
        - resourceType
        - rawJson
      type: object
      additionalProperties: false
    VantaTestSnapshotOutOfScopeResources:
      description: |-
        Resources excluded from the test at snapshot time, grouped by exclusion
        reason.  `testLevel` contains resources the customer disabled for the
        test; `frameworkLevel` contains resources scoped out by the framework's
        segment configuration.
      properties:
        testLevel:
          items:
            $ref: '#/components/schemas/VantaTestSnapshotExcludedItemGroup'
          type: array
        frameworkLevel:
          items:
            $ref: '#/components/schemas/VantaTestSnapshotFrameworkExclusion'
          type: array
      required:
        - testLevel
        - frameworkLevel
      type: object
      additionalProperties: false
    VantaTestSnapshotApiRequest:
      description: A single API request captured during an API introspection test run.
      properties:
        id:
          type: string
        resourceType:
          type: string
        resourceTypeDisplayName:
          type: string
        requestMethod:
          type: string
        url:
          type: string
        responseCode:
          type: number
          format: double
        timestamp:
          type: string
          format: date-time
        dataTooLarge:
          type: boolean
      required:
        - id
        - resourceType
        - resourceTypeDisplayName
        - requestMethod
        - url
        - responseCode
        - timestamp
        - dataTooLarge
      type: object
      additionalProperties: false
    VantaTestSnapshotSlaRemediationSettings:
      properties:
        numericValue:
          type: number
          format: double
        unit:
          type: string
          nullable: true
      required:
        - numericValue
        - unit
      type: object
      additionalProperties: false
    VantaTestSnapshotExcludedItemGroup:
      properties:
        reason:
          type: string
        entities:
          items:
            $ref: '#/components/schemas/VantaTestSnapshotExcludedItem'
          type: array
      required:
        - reason
        - entities
      type: object
      additionalProperties: false
    VantaTestSnapshotFrameworkExclusion:
      properties:
        frameworkId:
          type: string
        frameworkName:
          type: string
        groupedByReason:
          items:
            $ref: '#/components/schemas/VantaTestSnapshotExcludedItemGroup'
          type: array
      required:
        - frameworkId
        - frameworkName
        - groupedByReason
      type: object
      additionalProperties: false
    VantaTestSnapshotExcludedItem:
      properties:
        id:
          type: string
        displayName:
          type: string
          nullable: true
      required:
        - id
        - displayName
      type: object
      additionalProperties: false
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

````