Process Street File Uploads API

A file upload is a two-step upload for large files. Create one to get an upload URL and a `fileUploadId`, send the file's bytes to that URL, then attach the upload to a target (form field value, attachment, or page/workflow widget) via that target's `/upload` endpoint. The `fileUploadId` is single-use — attaching it consumes it.

Operations 1

POST /file-uploads Create a file upload #

Documentation

Specifications

Other Resources

Work with this as data

Every API here is available over the APIs.io API and to AI agents over MCP.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for apis

7 MCP tools reach this
  • find_apisBrowse and filter every API in the catalog.
  • get_api_artifactsOne API's artifacts, grouped by type.
  • get_openapiThe primary OpenAPI for this API.
  • find_similar_apisAPIs that look like this one.
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
This API
curl "https://apis.io/api/v1/apis/process-street-file-uploads-api"
All apis
curl "https://apis.io/api/v1/apis?limit=25"

Discovery needs no key. Ratings and market analysis are Pro.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. See our Privacy Policy and Terms.

A second provider on the same verified email joins the account you already have.

OpenAPI Specification

process-street-file-uploads-api-openapi.yml Raw ↑
openapi: 3.2.0
info:
  title: Process Street Public File Uploads API
  version: '1.1'
  description: The Process Street API is organized around REST.
servers:
- url: https://public-api.process.st/api/v1.1
tags:
- name: File Uploads
  description: 'A file upload is a two-step upload for large files. Create one to get an upload URL and a

    `fileUploadId`, send the file''s bytes to that URL, then attach the upload to a target (form field

    value, attachment, or page/workflow widget) via that target''s `/upload` endpoint. The `fileUploadId`

    is single-use — attaching it consumes it.'
paths:
  /file-uploads:
    post:
      tags:
      - File Uploads
      summary: Create a file upload
      description: Returns a single-use upload URL and a `fileUploadId`. Upload the file's bytes to `uploadUrl` with an HTTP `PUT` (sending the same `Content-Type` you declared), then attach the upload to a target by passing the `fileUploadId` to one of the `/upload` endpoints. Lets you upload large files without sending them through the API.
      operationId: createFileUpload
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateFileUploadRequest'
            examples:
              PDF document:
                summary: Uploading a quarterly invoice to later attach to a form field value
                value:
                  filename: invoice-2026-Q1.pdf
                  contentType: application/pdf
                  sizeBytes: 248173
              Image file:
                summary: Uploading a photo to later attach as a task attachment
                value:
                  filename: site-photo.jpg
                  contentType: image/jpeg
                  sizeBytes: 1048576
        required: true
      responses:
        '201':
          description: ''
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicApiFileUploadResponse'
        '400':
          description: 'Invalid value for: body'
          content:
            text/plain:
              schema:
                type: string
        default:
          description: ''
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorInfo'
      security:
      - apiKeyAuth: []
      - httpAuth: []
components:
  schemas:
    PublicApiFileUploadResponse:
      title: PublicApiFileUploadResponse
      type: object
      required:
      - data
      properties:
        data:
          title: PublicApiFileUpload
          description: The resource returned by this request.
          type: object
          required:
          - fileUploadId
          - uploadUrl
          - uploadMethod
          - uploadExpiresDate
          properties:
            fileUploadId:
              description: Opaque, single-use handle for this upload. Pass it to an `/upload` endpoint to attach the uploaded file to a target. Treat it as an opaque token.
              type: string
            uploadUrl:
              description: The URL to upload the file's bytes to, with a single `PUT` request.
              type: string
            uploadMethod:
              description: HTTP method to use when uploading to `uploadUrl`. Always `PUT`.
              type: string
            uploadExpiresDate:
              description: When `uploadUrl` expires. ISO-8601 UTC. Upload the bytes before this time.
              type: string
              format: date-time
        links:
          description: 'Pagination links. When the result has more pages, look for an entry with `name: "next"` — its `href` is the URL to fetch the next page. Absence of `next` means there are no more pages. For single-resource responses this array is typically empty.'
          type: array
          items:
            title: Link
            description: A HATEOAS link to a related resource. Use these to navigate between resources without constructing URLs by hand.
            type: object
            required:
            - name
            - href
            - type
            properties:
              name:
                description: Standard link relation name (RFC 5988) indicating this link's role. Common values include `self`, `edit`, `related`, `previous`, `next`.
                type: string
              href:
                title: Uri
                description: URL of the linked resource.
                examples:
                - https://api.process.st/api/v1.1/resource/XXX
                type: string
              rel:
                description: Optional. The kind of resource this link points to (e.g. `Workflow`, `Task`, `Comment`).
                type: string
                enum:
                - Approval Task
                - Approvals
                - Assignees
                - Comment
                - Data Set Records
                - Data Sets
                - Form Field Values
                - Subject Task
                - Task
                - Tasks
                - Users
                - Webhook
                - Workflow
                - Workflow Run
              type:
                description: Whether this link targets an API endpoint or a Process Street app URL. `Api` — a callable API endpoint you can fetch directly. `App` — a browser-facing URL in the Process Street UI.
                type: string
                enum:
                - Api
                - App
    CreateFileUploadRequest:
      title: CreateFileUploadRequest
      type: object
      required:
      - filename
      - contentType
      - sizeBytes
      properties:
        filename:
          description: The original file name, including its extension.
          type: string
          maxLength: 255
          minLength: 1
        contentType:
          description: The MIME type of the file (e.g. `application/pdf`). You must send this exact value as the `Content-Type` header when uploading to `uploadUrl`.
          type: string
          minLength: 1
        sizeBytes:
          description: The size of the file in bytes.
          type: integer
          format: int64
          minimum: 1
    ErrorInfo:
      title: ErrorInfo
      type: object
      required:
      - error
      properties:
        error:
          description: 'Human-readable error message. Suitable for logs or for surfacing to end users; do not parse it

            programmatically — use `errorCode` for that.'
          type: string
        details:
          description: 'Optional structured context. Shape depends on the error: for `Validation` errors the keys are field

            paths; for `PaymentRequired` the keys describe the limit that was hit.'
          type: object
          additionalProperties:
            type: string
        errorCode:
          title: ErrorCode
          description: 'Machine-parsable classification of the error. Always set on responses generated by the global

            exception handler. Branch your own error handling on this (not the message text).'
          type: string
          enum:
          - BadRequest
          - Unauthorized
          - PaymentRequired
          - Forbidden
          - NotFound
          - MethodNotAllowed
          - Conflict
          - PayloadTooLarge
          - Validation
          - RateLimited
          - InternalError
        requestId:
          description: Per-request correlation ID. Include this when contacting support so we can find the request in our logs.
          type: string
  securitySchemes:
    apiKeyAuth:
      type: apiKey
      name: X-API-Key
      in: header
    httpAuth:
      type: http
      description: Bearer token (beta)
      scheme: bearer
x-tagGroups:
- name: Workflows
  tags:
  - Workflows
  - Workflow Revisions
  - Form Fields
  - Workflow Logic Rules
  - Workflow Tasks
  - Workflow Task Assignment Rules
  - Workflow Widgets
  - Workflow Due Date Rules
  - Workflow Task Due Date Rules
  - Workflow Incoming Webhooks
  - Scheduled Workflows
- name: Workflow Runs
  tags:
  - Workflow Runs
  - Tasks
  - Form Field Values
  - Comments
  - Attachments
- name: Pages
  tags:
  - Pages
  - Page Revisions
  - Page Widgets
- name: Data Sets
  tags:
  - Data Sets
  - Data Set Incoming Webhooks
- name: Other
  tags:
  - Folders
  - One-Off Tasks
  - Users
  - Webhooks
  - File Uploads
  - Utilities
  - My Work