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

# Upload a run file

> Stores one file of at most 64 MiB; a larger one goes up in parts (`/uploads/`). The body must match `X-Content-SHA256`. Putting a path again replaces the file.



## OpenAPI

````yaml /api-reference/openapi.yaml put /v1/robot/runs/{robot}/{run}/files/{path}
openapi: 3.1.0
info:
  title: Abstract API
  version: 1.0.0
  summary: Robot action models and LLMs behind one API key.
  description: >
    `POST /v1/chat/completions` serves the robot action models. `POST
    /v1/responses` and

    `GET /v1/responses/{response_id}` serve the LLM models through the OpenAI
    Responses API.

    `GET /v1/models` lists the LLM model ids.


    The robot models also run over a WebSocket at
    `wss://api.abstract.inc/v1/responses`.

    OpenAPI does not describe it. See [Sessions over
    WebSocket](/robots/sessions).


    `/v1/robot/runs` stores your robot runs (episode logs, the Rerun recording
    with the

    camera video) under your account, and lists, downloads and deletes them.
    Only the key's

    account reaches its runs. An account stores up to 100 GiB of runs;

    `GET /v1/robot/runs/usage` shows what it holds.
  contact:
    name: Abstract
    url: https://abstract.inc
servers:
  - url: https://api.abstract.inc
security:
  - bearerAuth: []
tags:
  - name: Robot models
  - name: Robot runs
  - name: LLM models
paths:
  /v1/robot/runs/{robot}/{run}/files/{path}:
    put:
      tags:
        - Robot runs
      summary: Upload a run file
      description: >-
        Stores one file of at most 64 MiB; a larger one goes up in parts
        (`/uploads/`). The body must match `X-Content-SHA256`. Putting a path
        again replaces the file.
      operationId: uploadRobotRunFile
      parameters:
        - $ref: '#/components/parameters/Robot'
        - $ref: '#/components/parameters/Run'
        - $ref: '#/components/parameters/FilePath'
        - name: X-Content-SHA256
          in: header
          required: true
          description: The body's SHA-256, 64 hex digits.
          schema:
            type: string
            pattern: ^[0-9a-f]{64}$
      requestBody:
        required: true
        content:
          application/octet-stream:
            schema:
              type: string
              format: binary
      responses:
        '201':
          description: The file is stored.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RobotRunFile'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '411':
          description: '`length_required`: the request has no Content-Length.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '413':
          description: >-
            `request_too_large` (over 64 MiB), `run_too_large` (over 2 GiB or
            2,000 files in the run) or `storage_quota_exceeded` (the account
            would hold more than its quota).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '422':
          description: >-
            `checksum_mismatch`: the body is not the SHA-256 sent; or
            `invalid_request`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '503':
          description: '`storage_unavailable` or `auth_unavailable`. Retry with backoff.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
components:
  parameters:
    Robot:
      name: robot
      in: path
      required: true
      description: Your robot's name, for example `t800`.
      schema:
        type: string
        pattern: ^[a-z0-9][a-z0-9._-]{0,63}$
    Run:
      name: run
      in: path
      required: true
      description: The run's name, its start time as `YYYYMMDD-HHMMSS`.
      schema:
        type: string
        pattern: ^\d{8}-\d{6}$
    FilePath:
      name: path
      in: path
      required: true
      description: >-
        The file's path in the run. It may hold `/`; up to 8 segments of
        letters, digits, `.`, `_` and `-`, each starting with a letter or digit,
        512 bytes in all. `manifest.json` at the top is the server's.
      schema:
        type: string
  schemas:
    RobotRunFile:
      type: object
      required:
        - path
        - size
        - sha256
      properties:
        path:
          type: string
        size:
          type: integer
        sha256:
          type: string
          pattern: ^[0-9a-f]{64}$
    ErrorResponse:
      type: object
      required:
        - error
      properties:
        error:
          type: object
          required:
            - message
            - type
            - code
          properties:
            message:
              type: string
              description: For people. It can change.
            type:
              type: string
            param:
              type:
                - string
                - 'null'
              description: The request field at fault, when one is.
            code:
              type: string
              description: Branch on this. See [Errors and limits](/errors).
  responses:
    Unauthorized:
      description: '`missing_api_key` or `invalid_api_key`.'
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            error:
              message: Invalid API key.
              type: invalid_request_error
              code: invalid_api_key
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        Your Abstract API key. Get it with `abstract login`, pass it as
        `$(abstract token)`.

````

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