> ## 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.

# Start an auditor file upload

> Starts an upload of a file an auditor provides for the customer, such as
instructions or a template, on an information request. This does not upload
customer evidence. Use this three-step flow:

1. Call this endpoint with `email`, `filename` and `contentType` to receive




   an `uploadId`, a temporary `url` and form `fields`.
2. POST the file to `url` as `multipart/form-data` before `transferExpiresAt`.




   Copy every returned field name and value unchanged, then append the file
   under `file` as the final part. Do not hard-code the field names or send
   your Vanta bearer token to this URL. Let your HTTP client set the
   multipart Content-Type header and boundary. Wait for a 2xx response;
   the response body may be empty.
3. POST `{ "uploadId": "<returned uploadId>" }` to




   `/v1/audits/{auditId}/information-requests/{requestId}/auditor-files/uploads/finalize`
   and complete finalization before `finalizationExpiresAt`.

The file is attached only after finalization succeeds. Each upload accepts
one file up to 50MB, inclusive. The auditor identified
by `email` is credited as the uploader and must be an active user in your
firm with access to the audit. A completed audit returns 409.

Each application is limited to 10 unfinished auditor file uploads per
customer, across all audits and requests. Uploads count toward this limit
until they are finalized, fail, or expire. Starting another upload at this
limit returns 429, even if the earlier file transfers have succeeded.
Repeating this start operation creates a new upload; it does not recover
an earlier upload whose response was lost.

Rate limit: 10 requests / minute.



## OpenAPI

````yaml https://spec.speakeasy.com/vanta/vanta/conduct-an-audit-with-code-samples post /audits/{auditId}/information-requests/{requestId}/auditor-files/uploads
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}/auditor-files/uploads:
    post:
      tags:
        - Audits
      summary: Start an auditor file upload
      description: >-
        Starts an upload of a file an auditor provides for the customer, such as

        instructions or a template, on an information request. This does not
        upload

        customer evidence. Use this three-step flow:


        1. Call this endpoint with `email`, `filename` and `contentType` to
        receive




           an `uploadId`, a temporary `url` and form `fields`.
        2. POST the file to `url` as `multipart/form-data` before
        `transferExpiresAt`.




           Copy every returned field name and value unchanged, then append the file
           under `file` as the final part. Do not hard-code the field names or send
           your Vanta bearer token to this URL. Let your HTTP client set the
           multipart Content-Type header and boundary. Wait for a 2xx response;
           the response body may be empty.
        3. POST `{ "uploadId": "<returned uploadId>" }` to




           `/v1/audits/{auditId}/information-requests/{requestId}/auditor-files/uploads/finalize`
           and complete finalization before `finalizationExpiresAt`.

        The file is attached only after finalization succeeds. Each upload
        accepts

        one file up to 50MB, inclusive. The auditor identified

        by `email` is credited as the uploader and must be an active user in
        your

        firm with access to the audit. A completed audit returns 409.


        Each application is limited to 10 unfinished auditor file uploads per

        customer, across all audits and requests. Uploads count toward this
        limit

        until they are finalized, fail, or expire. Starting another upload at
        this

        limit returns 429, even if the earlier file transfers have succeeded.

        Repeating this start operation creates a new upload; it does not recover

        an earlier upload whose response was lost.


        Rate limit: 10 requests / minute.
      operationId: InitiateInformationRequestAuditorFileUpload
      parameters:
        - in: path
          name: auditId
          required: true
          schema:
            type: string
        - in: path
          name: requestId
          required: true
          schema:
            type: string
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/InitiateAuditorFileUploadInput'
      responses:
        '200':
          description: Ok
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AuditorFileUploadGrant'
              examples:
                Example 1:
                  value:
                    uploadId: 7630c3ba-51c3-4410-84d1-3b79d6a8eb1d
                    url: https://uploads.example.com/
                    fields:
                      key: example-upload-key
                      Content-Type: text/csv
                      Policy: example-base64-policy
                      X-Amz-Signature: example-signature
                    maxSizeBytes: 52428800
                    transferExpiresAt: '2026-11-03T12:01:00.000Z'
                    finalizationExpiresAt: '2026-11-03T12:10:00.000Z'
        '400':
          description: Invalid request body or path parameters; correct the input
        '401':
          description: Missing or expired Vanta access token
        '403':
          description: The application or named auditor lacks access
        '404':
          description: The audit or information request was not found
        '409':
          description: The audit is completed; reopen it before uploading
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OutboundError'
        '422':
          description: >-
            Unsupported contentType, audit not yet available, or upload could
            not start before its transfer deadline
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OutboundError'
        '429':
          description: >-
            Request rate or unfinished-upload limit reached; back off before
            starting another upload
        '500':
          description: Unexpected server error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OutboundError'
      security:
        - bearerAuth: []
      x-codeSamples:
        - lang: typescript
          label: InitiateInformationRequestAuditorFileUpload
          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.initiateInformationRequestAuditorFileUpload({
                auditId: "<id>",
                requestId: "<id>",
                initiateAuditorFileUploadInput: {
                  email: "Kelly49@hotmail.com",
                  filename: "example.file",
                  contentType: "<value>",
                },
              });

              console.log(result);
            }

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


            import com.vanta.vanta_auditor_api.Vanta;

            import
            com.vanta.vanta_auditor_api.models.components.InitiateAuditorFileUploadInput;

            import com.vanta.vanta_auditor_api.models.errors.OutboundError;

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

            import java.lang.Exception;


            public class Application {

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

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

                    InitiateInformationRequestAuditorFileUploadResponse res = sdk.audits().initiateInformationRequestAuditorFileUpload()
                            .auditId("<id>")
                            .requestId("<id>")
                            .initiateAuditorFileUploadInput(InitiateAuditorFileUploadInput.builder()
                                .email("Kelly49@hotmail.com")
                                .filename("example.file")
                                .contentType("<value>")
                                .build())
                            .call();

                    if (res.auditorFileUploadGrant().isPresent()) {
                        System.out.println(res.auditorFileUploadGrant().get());
                    }
                }
            }
components:
  schemas:
    InitiateAuditorFileUploadInput:
      properties:
        email:
          type: string
          description: >-
            Email of the auditor to credit as the uploader. They must be an
            active user

            in your audit firm with access to the audit, including when you
            finalize.
        filename:
          type: string
          description: >-
            Filename to display on the attachment. Must be 1–255 characters
            after trimming surrounding whitespace.
        contentType:
          type: string
          description: >-
            The file's declared MIME type. Accepted values:

            - `application/json`

            - `application/pdf`

            - `application/postscript`

            -
            `application/vnd.openxmlformats-officedocument.wordprocessingml.document`

            -
            `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`

            - `application/x-zip-compressed`

            - `application/zip`

            - `image/jpeg`

            - `image/png`

            - `image/webp`

            - `text/csv`

            - `text/plain`


            Matching ignores case and MIME parameters, so `TEXT/CSV` and

            `text/csv; charset=utf-8` are also accepted. Unsupported file types
            return

            `422` during finalization.
      required:
        - email
        - filename
        - contentType
      type: object
      additionalProperties: false
    AuditorFileUploadGrant:
      properties:
        uploadId:
          type: string
          description: >-
            Opaque identifier for this upload. Pass it unchanged to finalize; it
            is not the attached file's ID.
        url:
          type: string
          description: >-
            Temporary URL for the file-transfer request. POST every returned
            `fields`

            entry and the file to this URL, without a Vanta Authorization
            header.

            This is not a download link.
        fields:
          $ref: '#/components/schemas/AuditorFileUploadFormFields'
        maxSizeBytes:
          type: number
          format: double
          description: Maximum file size in bytes, inclusive. The limit is 50MB.
        transferExpiresAt:
          type: string
          format: date-time
          description: >-
            UTC expiration timestamp for `url` and `fields`. Start the
            file-transfer POST well before this time.
        finalizationExpiresAt:
          type: string
          format: date-time
          description: >-
            UTC deadline to complete finalization and attach the file, even if
            the file transfer has already succeeded.
      required:
        - uploadId
        - url
        - fields
        - maxSizeBytes
        - transferExpiresAt
        - finalizationExpiresAt
      type: object
      additionalProperties: false
    OutboundError:
      properties:
        message:
          type: string
      required:
        - message
      type: object
      additionalProperties: false
    AuditorFileUploadFormFields:
      description: >-
        Form fields to send with the file to `url`. Copy every returned name and

        value unchanged into a multipart/form-data POST, then append the file
        under

        `file` as the final part. These are form fields, not HTTP headers. Field

        names may vary between uploads; do not hard-code the example fields.
      properties: {}
      type: object
      additionalProperties:
        type: string
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

````

## Related topics

- [Complete an auditor file upload and attach the file](https://developer.vanta.com/api-reference/audits/complete-an-auditor-file-upload-and-attach-the-file.md)
- [List auditor files for an information request](https://developer.vanta.com/api-reference/audits/list-auditor-files-for-an-information-request.md)
- [Upload a document](https://developer.vanta.com/docs/guides/upload-a-document.md)
- [Upload file for document](https://developer.vanta.com/api-reference/documents/upload-file-for-document.md)
- [List document's uploads](https://developer.vanta.com/api-reference/documents/list-documents-uploads.md)
