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

# Bulk Create Workspace Word Memories

> Create multiple word memories in a workspace in one request (up to 1000). Duplicate `(entry, subEntry)` pairs are silently skipped, so the response contains only the newly created entries. Requires a **user** API key that is a writable member of the workspace; a workspace-bound key must match the path.




## OpenAPI

````yaml /openapi.yaml post /v1/external/workspaces/{workspaceGuid}/word-memories/bulk
openapi: 3.1.0
info:
  title: Tiro API
  description: AI-powered note-taking and voice file processing API
  version: 1.0.0
  contact:
    name: Tiro Support
    email: support@tiro.ooo
    url: https://tiro.ooo
servers:
  - url: https://api.tiro.ooo
    description: Production server
security:
  - BearerAuth: []
tags:
  - name: Note
    description: Operations for managing notes and their paragraphs
  - name: Note Share Link
    description: Manage share links for notes
  - name: Note Summary
    description: Operations for retrieving note summaries
  - name: Note Document
    description: Template-based document generation from notes
  - name: Note Document Template
    description: Operations for managing note document templates
  - name: Folder
    description: Operations for retrieving folders
  - name: Voice File
    description: Operations for voice file processing
  - name: Word Memory
    description: >
      Manage word memories to improve voice transcription accuracy. Register
      important terms like company names, people's names, and product names so
      Tiro recognizes them precisely during recording. Each term has an `entry`
      and an optional `subEntry` (an alternate spelling or notation). Personal
      (User), workspace-shared (Workspace), and organization-shared
      (Organization) word memories are managed separately, and each scope
      supports bulk create/update/delete (up to 1000 items per request).
  - name: Wiki
    description: |
      Access workspace wikis — unified knowledge graphs built from notes.
      Requires a workspace with wiki plan and activation enabled.
  - name: Organization
    description: >
      Endpoints for organization API keys. An organization key is issued by an

      organization admin, carries fixed scopes chosen at issuance, and can reach

      the notes in every workspace that belongs to the organization. Built for

      server-to-server integrations such as CRM sync — receive `note.ended`
      webhook

      events, generate documents for notes, and reconcile with the organization

      notes list.
  - name: Organization Management
    description: Operations for the authenticated user's organization.
paths:
  /v1/external/workspaces/{workspaceGuid}/word-memories/bulk:
    post:
      tags:
        - Word Memory
      summary: Bulk Create Workspace Word Memories
      description: >
        Create multiple word memories in a workspace in one request (up to
        1000). Duplicate `(entry, subEntry)` pairs are silently skipped, so the
        response contains only the newly created entries. Requires a **user**
        API key that is a writable member of the workspace; a workspace-bound
        key must match the path.
      operationId: bulkCreateWorkspaceWordMemories
      parameters:
        - name: workspaceGuid
          in: path
          required: true
          description: Workspace GUID. Obtain it from `GET /v1/external/workspaces`.
          schema:
            type: string
          example: ws_a1b2c3d4
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/BulkCreateWordMemoryRequest'
            example:
              entries:
                - entry: 딥러닝
                  subEntry: DL
                - entry: 자연어처리
      responses:
        '201':
          description: Created word memories (duplicates skipped)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/WordMemoryListResponse'
        '400':
          description: Bad request — empty list, more than 1000 items, or a blank entry
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '401':
          description: Unauthorized — missing API key, or a system/team-only key was used
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '403':
          description: >-
            Forbidden — the API key is not scoped to this workspace, or you are
            not a writable member of it
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '404':
          description: Workspace not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
components:
  schemas:
    BulkCreateWordMemoryRequest:
      type: object
      required:
        - entries
      properties:
        entries:
          type: array
          minItems: 1
          maxItems: 1000
          description: >-
            Word memories to create. Duplicate `(entry, subEntry)` pairs —
            against both existing entries and other items in the same request —
            are silently skipped (idempotent, safe for CSV re-upload).
          items:
            $ref: '#/components/schemas/CreateWordMemoryRequest'
    WordMemoryListResponse:
      type: object
      required:
        - content
      properties:
        content:
          type: array
          items:
            $ref: '#/components/schemas/WordMemory'
        totalSize:
          type: integer
          format: int64
          nullable: true
          description: Always `null` for bulk responses
          example: null
    Error:
      type: object
      required:
        - error
      properties:
        error:
          type: object
          required:
            - code
            - errorType
            - message
          properties:
            code:
              type: integer
              description: >
                6-digit error code in `AAABBB` form: first 3 digits match the
                HTTP status,

                last 3 digits are a per-status serial (e.g. `404018`). Use only
                when you need

                to distinguish specific error cases within the same HTTP status
                — values may be

                added or renumbered across releases. For general client
                branching, prefer `errorType`.
              example: 404018
            errorType:
              type: string
              description: >
                Stable, coarse-grained error category. Recommended default for
                client-side

                branching: the value-to-status mapping is part of the API
                contract and will not

                change without a breaking-change notice. Typical use:
                  - `unauthorized` → trigger re-authentication
                  - `forbidden` → surface a permission error to the user
                  - `not_found` → treat as missing resource
                  - `too_many_requests` → back off and retry
                  - `internal_error` → retry with exponential backoff
              enum:
                - bad_request
                - unauthorized
                - forbidden
                - not_found
                - not_acceptable
                - conflict
                - payload_too_large
                - unprocessable_entity
                - too_many_requests
                - internal_error
              example: not_found
            message:
              type: string
              description: >-
                Human-readable error message. Not stable; do not use for
                branching.
              example: 'No team found for user #217'
            detail:
              type: string
              nullable: true
              description: Additional error details
              example: null
    CreateWordMemoryRequest:
      type: object
      required:
        - entry
      properties:
        entry:
          type: string
          minLength: 1
          maxLength: 63
          description: The word or term to register. Must not be blank. Max 63 characters.
          example: 인공지능
        subEntry:
          type: string
          nullable: true
          maxLength: 63
          description: >-
            Optional secondary form of the term (e.g. an alternate spelling).
            Max 63 characters.
          example: AI
    WordMemory:
      type: object
      required:
        - id
        - entry
        - createdAt
      properties:
        id:
          type: integer
          format: int64
          description: Unique identifier of the word memory
          example: 1
        entry:
          type: string
          description: The registered word or term
          example: 인공지능
        subEntry:
          type: string
          nullable: true
          description: >
            Optional secondary form of the term — for example an alternate
            spelling or written notation paired with the pronunciation in
            `entry`. `null` when not set.
          example: AI
        createdAt:
          type: string
          format: date-time
          description: When the word memory was created (ISO 8601)
          example: '2026-04-01T10:30:00Z'
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      description: API key in format {id}.{secret}

````