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

# Submit Files for Scanning

> Submit files for malware scanning.

**Limits.** At most **20 files**, **25 MB per file**, and **50 MB for the
whole request**. The request total is usually what binds: twenty files at the
per-file maximum is far more than 50 MB, so large files run out of request
budget long before they run out of slots. Send big files in smaller batches.

Note the two are refused differently. An oversized *file* is rejected on its
own and the rest of the batch still succeeds. An oversized *request* is
refused whole, with **413**, before any file is read — there is no per-file
detail available at that point because nothing was parsed.

**Per-file outcomes.** Every file gets its own entry in ``files[]`` with
``accepted`` and, when rejected, an ``error``. One bad file never discards the
good ones sent with it.

**What comes back.** Accepted files are ``pending`` with an ``id``. A verdict
is not instant. Subscribe to the ``file_scan`` webhook group, or poll
``GET /file-scans/{file_id}``. Each file produces its **own** webhook when its
own scan finishes, so ten accepted files mean up to ten separate webhooks,
arriving independently and in no guaranteed order. Rejected files produce
none — they were never stored, so they are never scanned.



## OpenAPI

````yaml POST /v1/platform/file-scans
openapi: 3.1.0
info:
  title: Finogate Platform API v1
  version: 0.1.0
servers:
  - url: https://api-sandbox.finogates.com
    description: Sandbox
  - url: https://api.finogates.com
    description: Production
security: []
tags:
  - name: auth
  - name: users
  - name: payees
  - name: verification
  - name: bank accounts
  - name: card processing
  - name: digital-assets
  - name: international
  - name: fees
  - name: onboarding
  - name: pending-applications
  - name: wallets
  - name: payments
  - name: document mailing
  - name: merchant onboarding
  - name: catalog
  - name: webhooks
  - name: screening
  - name: Platform - File Scanning
  - name: phone-numbers
  - name: sms
  - name: calls
  - name: listings
  - name: Card Transfers
  - name: embed-tokens
paths:
  /v1/platform/file-scans:
    post:
      tags:
        - Platform - File Scanning
      summary: Submit Files For Scanning
      description: >-
        Submit files for malware scanning.


        **Limits.** At most **20 files**, **25 MB per file**, and **50 MB for
        the

        whole request**. The request total is usually what binds: twenty files
        at the

        per-file maximum is far more than 50 MB, so large files run out of
        request

        budget long before they run out of slots. Send big files in smaller
        batches.


        Note the two are refused differently. An oversized *file* is rejected on
        its

        own and the rest of the batch still succeeds. An oversized *request* is

        refused whole, with **413**, before any file is read — there is no
        per-file

        detail available at that point because nothing was parsed.


        **Per-file outcomes.** Every file gets its own entry in ``files[]`` with

        ``accepted`` and, when rejected, an ``error``. One bad file never
        discards the

        good ones sent with it.


        **What comes back.** Accepted files are ``pending`` with an ``id``. A
        verdict

        is not instant. Subscribe to the ``file_scan`` webhook group, or poll

        ``GET /file-scans/{file_id}``. Each file produces its **own** webhook
        when its

        own scan finishes, so ten accepted files mean up to ten separate
        webhooks,

        arriving independently and in no guaranteed order. Rejected files
        produce

        none — they were never stored, so they are never scanned.
      operationId: submit_files_for_scanning_v1_platform_file_scans_post
      requestBody:
        required: true
        content:
          multipart/form-data:
            schema:
              $ref: >-
                #/components/schemas/Body_submit_files_for_scanning_v1_platform_file_scans_post
      responses:
        '200':
          description: >-
            Per-file acceptance outcomes. Accepted files are `pending` with an
            `id`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CommonResponse_FileScanUploadResponse_'
              example:
                status_code: 201
                data:
                  accepted_count: 2
                  rejected_count: 1
                  files:
                    - file_name: signed-contract.pdf
                      accepted: true
                      id: 7c4d2e1a-8b3f-4d6c-9a1e-5f2b3c4d5e6f
                      status: pending
                    - file_name: id-scan.jpg
                      accepted: true
                      id: 8d5e3f2b-9c4a-4e7d-8b2f-6a3c4d5e6f70
                      status: pending
                    - file_name: promo-clip.mp4
                      accepted: false
                      error: file exceeds the 25 MB per-file limit
                query_generated_time: 1712847600000
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
      security:
        - _AuthenticatedBearer: []
components:
  schemas:
    Body_submit_files_for_scanning_v1_platform_file_scans_post:
      properties:
        files:
          items:
            type: string
            format: binary
          type: array
          title: Files
          description: >-
            One or more files to scan; repeat the field per file. At most 20
            files, 25 MB per file, and 50 MB for the whole request.
        category:
          anyOf:
            - type: string
            - type: 'null'
          title: Category
          description: Optional label for your own grouping, e.g. 'contracts'.
      type: object
      required:
        - files
      title: Body_submit_files_for_scanning_v1_platform_file_scans_post
    CommonResponse_FileScanUploadResponse_:
      properties:
        status_code:
          type: integer
          title: Status Code
          description: HTTP status code for the response.
        data:
          $ref: '#/components/schemas/FileScanUploadResponse'
          description: Payload or error details.
        query_generated_time:
          type: integer
          title: Query Generated Time
          description: >-
            UTC timestamp (milliseconds since epoch) when response was
            generated.
      type: object
      required:
        - status_code
        - data
        - query_generated_time
      title: CommonResponse[FileScanUploadResponse]
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
      type: object
      title: HTTPValidationError
    FileScanUploadResponse:
      properties:
        accepted_count:
          type: integer
          title: Accepted Count
        rejected_count:
          type: integer
          title: Rejected Count
        files:
          items:
            $ref: '#/components/schemas/FileScanUploadRead'
          type: array
          title: Files
      type: object
      required:
        - accepted_count
        - rejected_count
        - files
      title: FileScanUploadResponse
      description: The outcome of a multi-file submission.
    ValidationError:
      properties:
        loc:
          items:
            anyOf:
              - type: string
              - type: integer
          type: array
          title: Location
        msg:
          type: string
          title: Message
        type:
          type: string
          title: Error Type
      type: object
      required:
        - loc
        - msg
        - type
      title: ValidationError
    FileScanUploadRead:
      properties:
        file_name:
          type: string
          title: File Name
        accepted:
          type: boolean
          title: Accepted
        id:
          anyOf:
            - type: string
              format: uuid
            - type: 'null'
          title: Id
          description: Null when the file was rejected.
        status:
          anyOf:
            - type: string
            - type: 'null'
          title: Status
          description: '''pending'' on acceptance; null when rejected.'
        error:
          anyOf:
            - type: string
            - type: 'null'
          title: Error
          description: Why this file was rejected. Null when accepted.
      type: object
      required:
        - file_name
        - accepted
      title: FileScanUploadRead
      description: >-
        The result of one submitted file, in a multi-file upload.


        Per-file rather than per-request: one rejected file must not discard the

        others that were accepted in the same call, so each carries its own
        outcome.
  securitySchemes:
    _AuthenticatedBearer:
      type: oauth2
      flows:
        password:
          scopes: {}
          tokenUrl: /v1/platform/auth/token

````