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

# Import Rows

> Stores up to 1000 records from a spreadsheet or another system, as JSON
values, without mapping or writing any records yet. It is the first step of
a bulk load or migration; tag the rows with an `importBatch`, then map them
into records with Queue Import Job (`queueFmv1ImportJob`). For one record
with an immediate result, use Import Entity (`createFmv1Import`).

Stores each element of `rows` unchanged as a separate import row. No entity type, mapping, guard or FMV1 configuration is needed. No attempt or entity is created. Returns the IDs in request order. Queue an import job to transform them, now or later.

A request accepts 1 to 1000 arbitrary JSON values; send multiple batches for larger loads. Repeating a request stores additional rows. Storage preserves JSON values, not the original JSON text's whitespace or key order.

For an indivisible source record too large for an ordinary request, send
`rowsGzipBase64` instead of `rows`: standard padded base64 of gzip-compressed
UTF-8 JSON for the whole rows array. The server authenticates before decoding,
accepts at most 16 MiB compressed and 128 MiB expanded, then validates and
stores the original values. Never send both alternatives. Encoded source
payloads are excluded from audit logs.

**Required permission:** any one of `event.import`, `exposure.import`, `quote.import`, `submission.import`, `person.import`, `organization.import` or `policy.import`. Untyped rows are readable by any caller holding one of these permissions in the company.




## OpenAPI

````yaml /openapi/generated-external-api.yaml post /api/v1/companies/{companyId}/imports/rows
openapi: 3.0.3
info:
  title: AI Insurance External API
  description: External API for AI Insurance platform
  version: 1.0.0
  contact:
    email: support@aiinsurance.io
servers:
  - url: https://go.aiinsurance.io
    description: Production
security:
  - ApiKeyAuth: []
paths:
  /api/v1/companies/{companyId}/imports/rows:
    post:
      tags:
        - Imports
      summary: Import Rows
      description: >
        Stores up to 1000 records from a spreadsheet or another system, as JSON

        values, without mapping or writing any records yet. It is the first step
        of

        a bulk load or migration; tag the rows with an `importBatch`, then map
        them

        into records with Queue Import Job (`queueFmv1ImportJob`). For one
        record

        with an immediate result, use Import Entity (`createFmv1Import`).


        Stores each element of `rows` unchanged as a separate import row. No
        entity type, mapping, guard or FMV1 configuration is needed. No attempt
        or entity is created. Returns the IDs in request order. Queue an import
        job to transform them, now or later.


        A request accepts 1 to 1000 arbitrary JSON values; send multiple batches
        for larger loads. Repeating a request stores additional rows. Storage
        preserves JSON values, not the original JSON text's whitespace or key
        order.


        For an indivisible source record too large for an ordinary request, send

        `rowsGzipBase64` instead of `rows`: standard padded base64 of
        gzip-compressed

        UTF-8 JSON for the whole rows array. The server authenticates before
        decoding,

        accepts at most 16 MiB compressed and 128 MiB expanded, then validates
        and

        stores the original values. Never send both alternatives. Encoded source

        payloads are excluded from audit logs.


        **Required permission:** any one of `event.import`, `exposure.import`,
        `quote.import`, `submission.import`, `person.import`,
        `organization.import` or `policy.import`. Untyped rows are readable by
        any caller holding one of these permissions in the company.
      operationId: ingestFmv1ImportRows
      parameters:
        - $ref: '#/components/parameters/companyId'
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/IngestImportRowsRequest'
            examples:
              sourceRows:
                summary: Store source data before choosing a mapping
                value:
                  importBatch: october-load
                  rows:
                    - sourceId: A-1
                      name: Acme
                    - sourceId: A-2
                      name: Other
      responses:
        '201':
          description: All rows stored, without transforming or writing entities.
          content:
            application/json:
              schema:
                type: object
                required:
                  - importRowIds
                  - importBatch
                properties:
                  importRowIds:
                    type: array
                    items:
                      type: string
                      format: uuid
                  importBatch:
                    type: string
                    nullable: true
        '400':
          description: Invalid request envelope or row count. No rows stored.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '500':
          $ref: '#/components/responses/InternalServerError'
      security:
        - BearerAuth: []
        - ApiKeyAuth: []
components:
  parameters:
    companyId:
      name: companyId
      in: path
      required: true
      schema:
        type: string
        format: uuid
      description: Company identifier
  schemas:
    IngestImportRowsRequest:
      type: object
      additionalProperties: false
      oneOf:
        - required:
            - rows
        - required:
            - rowsGzipBase64
      properties:
        rows:
          type: array
          minItems: 1
          maxItems: 1000
          items: {}
          description: >-
            Arbitrary JSON values stored unchanged, one import row per element.
            Null, scalars, arrays and objects are accepted.
        rowsGzipBase64:
          type: string
          minLength: 1
          maxLength: 22369624
          description: >
            Alternative to `rows` for large indivisible source records. Standard

            padded base64 of gzip-compressed UTF-8 JSON containing the complete
            rows

            array. Send exactly one of `rows` or `rowsGzipBase64`. The
            compressed bytes

            must not exceed 16 MiB, and the expanded JSON must not exceed 128
            MiB.

            The decoded array follows the same 1–1000 row validation and
            preserves

            every JSON value. Malformed or oversized payloads are rejected
            before

            any rows are stored. Authentication precedes decompression.
        importBatch:
          type: string
          nullable: true
          minLength: 1
          description: Optional non-blank batch key for selecting these rows later.
    ErrorResponse:
      type: object
      description: Standard error response for all external API endpoints
      required:
        - error
      properties:
        error:
          type: object
          required:
            - code
            - message
          properties:
            code:
              type: string
              description: Machine-readable error code
              example: VALIDATION_ERROR
            message:
              type: string
              description: Human-readable error message
              example: 'submissionId: Required field is missing'
            userMessages:
              type: array
              description: >-
                Clean, verbatim-displayable messages — one entry per failure,
                free of error-code tags, field paths, and internal noise.
                Suitable for showing to end users as-is.
              items:
                type: string
              example:
                - Exposures of type 'company' require an address
            details:
              type: array
              description: Additional details for validation errors (field-level errors)
              items:
                type: object
                properties:
                  field:
                    type: string
                    description: The field that caused the error
                    example: submissionId
                  code:
                    type: string
                    description: Stable problem code for this individual validation failure
                    example: BLANK_LIST_ELEMENT
                  reason:
                    type: string
                    description: Stable reason the value violates its canonical contract
                    example: blank-list-element
                  expected:
                    type: string
                    description: The expected canonical value contract
                    example: nonblank trimmed string
                  message:
                    type: string
                    description: Description of the field error
                    example: Required field is missing
  responses:
    Unauthorized:
      description: Unauthorized - Invalid or missing API key
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          examples:
            missingApiKey:
              summary: Missing API key
              value:
                error:
                  code: AuthenticationError
                  message: API key authentication required
                  userMessages:
                    - API key authentication required
            invalidApiKey:
              summary: >-
                Invalid API key (e.g. unknown key, or a Bearer token used
                instead of an API key)
              value:
                error:
                  code: AuthenticationError
                  message: Invalid API key
                  userMessages:
                    - Invalid API key
    Forbidden:
      description: Forbidden - Insufficient permissions
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          examples:
            insufficientPermissions:
              summary: Insufficient permissions
              value:
                error:
                  code: AuthorizationError
                  message: User is not authorized to perform the requested action
                  userMessages:
                    - User is not authorized to perform the requested action
            companyMismatch:
              summary: A valid API key naming another company in the URL
              value:
                error:
                  code: AuthorizationError
                  message: API key is not scoped to the requested company
                  userMessages:
                    - API key is not scoped to the requested company
    InternalServerError:
      description: Internal Server Error - Unexpected error occurred
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          examples:
            internalError:
              summary: Unexpected server error
              value:
                error:
                  code: UncaughtActionError
                  message: Uncaught error occurred in <actionName>
                  userMessages:
                    - An unexpected error occurred. Please try again later.
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: Authorization
      description: >-
        API key authentication. Send your raw API key as the `Authorization`
        header value with NO scheme prefix — `Authorization: YOUR-API-KEY`. Do
        NOT prefix it with `Bearer ` or `ApiKey `, and do not use an `X-API-Key`
        header; those are not accepted.
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: >-
        User-principal OAuth 2.0 Bearer authentication. Send a user-scoped Auth0
        access token (audience = the app API audience) as `Authorization: Bearer
        <jwt>`. The request resolves to the user's identity and is authorized by
        their Role on the `{companyId}` in the path — the same role-based
        permissions the web app enforces. This is the path the MCP connector
        uses to act on a user's behalf; endpoints that accept it list both
        `BearerAuth` and `ApiKeyAuth`.

````

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