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

# List translation memory segments

> Learn how to page through the source segments and translations stored in a translation memory using cursor-based pagination.

## Paginating with cursors

This endpoint pages with an opaque cursor, unlike [List translation memories](/api-reference/translation-memory/list-translation-memories), which uses numbered `page` values. Omit `page_cursor` on the first request, then pass each response's `next_page_cursor` to get the following page. A response with no `next_page_cursor` is the last page.

```bash theme={null}
# First page
curl -X GET "https://api.deepl.com/v3/translation_memories/a74d88fb-ed2a-4943-a664-a4512398b994/segments?page_size=50" \
  -H "Authorization: DeepL-Auth-Key <yourAuthKey>"

# Next page, using next_page_cursor from the response above
curl -X GET "https://api.deepl.com/v3/translation_memories/a74d88fb-ed2a-4943-a664-a4512398b994/segments?page_size=50&page_cursor=eyJvZmZzZXQiOjUwfQ" \
  -H "Authorization: DeepL-Auth-Key <yourAuthKey>"
```

Treat the cursor as opaque. Its format is not part of the API contract, so do not construct, decode, or increment it yourself. Cursors also encode the filter they were issued under: if you change `filter_text` or `filter_case_sensitive`, start again without a cursor.

<Warning>
  `segment_count` is the total for the whole translation memory and is not reduced by `filter_text`. A filtered request still reports the full count, so do not use it to decide how many pages of filtered results to expect. Stop paginating when `next_page_cursor` is absent.
</Warning>

## Filtering

`filter_text` matches against both source text and every target translation, and must be at least 2 characters. Matching is case-insensitive unless you set `filter_case_sensitive=true`.


## OpenAPI

````yaml get /v3/translation_memories/{translation_memory_id}/segments
openapi: 3.0.3
info:
  title: DeepL API Documentation
  description: >-
    The DeepL API provides programmatic access to DeepL’s language AI
    technology.


    Note: this OpenAPI spec is embedded into our API documentation and has
    shortened descriptions.
  termsOfService: https://www.deepl.com/pro-license
  contact:
    name: DeepL - Contact us
    url: https://www.deepl.com/contact-us
  version: 3.12.0
servers:
  - url: https://api.deepl.com
    description: DeepL API Pro
  - url: https://api-free.deepl.com
    description: DeepL API Free
security: []
tags:
  - name: beta
    description: >-
      Experimental features that are under testing and not yet intended for
      production use.
  - name: TranslateText
    description: >-
      The text-translation API currently consists of a single endpoint,
      `translate`, which is described below.
  - name: TranslateDocuments
    description: >-
      The document translation API allows you to translate whole documents and
      supports the following file types and extensions:
        * `docx` - Microsoft Word Document
        * `pptx` - Microsoft PowerPoint Document
        * `xlsx` - Microsoft Excel Document
        * `pdf` - Portable Document Format
        * `htm / html` - HTML Document
        * `txt` - Plain Text Document
        * `xlf / xliff` - XLIFF Document (versions 1.2, 2.0, and 2.1)
        * `srt` - SRT Document
        * `idml` - Adobe InDesign Markup Language
        * `xml` - XML Document
        * `json` - JSON Document
        * `dita` - DITA topic (Darwin Information Typing Architecture)
        * `mif` - Adobe FrameMaker Interchange Format
        * `jpeg` / `jpg` / `png` - Image (currently in beta)
  - name: RephraseText
    description: >-
      The `rephrase` endpoint  is used to make corrections and adjustments to
      texts based on style or tone.
  - name: CorrectText
    description: >-
      The `correct` endpoint fixes spelling and grammar errors without broader
      rephrasing. Use it when you want

      a minimal-change correction pass rather than the broader rewriting
      performed by `rephrase`.
  - name: ManageSpokenTerms
    description: >-
      The *Spoken Terms* functions allow you to create, inspect, edit and delete
      Spoken Terms collections.

      Spoken Terms improve speech recognition in the Voice API: they ensure
      specific words and phrases,

      such as company names, acronyms, and product names, are transcribed
      correctly. A collection contains

      one or more term lists, each holding terms for a single language, and is
      applied to a voice session

      via the `spoken_terms_id` parameter.
  - name: ManageMultilingualGlossaries
    description: >-
      The *glossary* functions allow you to create, inspect, edit and delete
      glossaries.

      Glossaries created with the glossary function can be used in translate
      requests by specifying the

      `glossary_id` parameter. A glossary contains (several) dictionaries.

      A dictionary is a mapping of source phrases to target phrases for a single
      language pair.

      If you encounter issues, please let us know at support@DeepL.com.


      Currently you can create glossaries with any of the languages DeepL
      supports (with the exception of Thai).


      The maximum size limit for a glossary is 10 MiB = 10485760 bytes and each
      source/target text,

      as well as the name of the glossary, is limited to 1024 UTF-8 bytes.

      A total of 1000 glossaries are allowed per account.


      When creating a dictionary with target language `EN`, `PT`, or `ZH`, it's
      not necessary to specify a variant

      (e.g. `EN-US`, `EN-GB`, `PT-PT`, `PT-BR`, or `ZH-HANS`).

      Dictionaries with target language `EN` can be used in translations with
      either English variant.

      Similarly `PT`, and `ZH` dictionaries can be used in translations with
      their corresponding variants.

      (When you provide the ID of a glossary to a translation, the appropriate
      dictionary is automatically applied. Currently glossaries can not yet be
      used with source language detection.)


      Glossaries created via the DeepL API are now unified with glossaries
      created via the DeepL website and DeepL apps.

      Please only use the v3 glossary API in conjunction with multilingual or
      edited glossaries from the website.
  - name: ManageGlossaries
    description: >-
      Please note that this is the spec for the (old) v2 glossary endpoint.

      We recommend users switch to the newer v3 glossary endpoints, which
      support editability and multilinguality.


      The *glossary* functions allow you to create, inspect, and delete
      glossaries.

      Glossaries created with the glossary function can be used in translate
      requests by specifying the

      `glossary_id` parameter.

      If you encounter issues, please let us know at support@DeepL.com.


      Currently you can create glossaries with any of the languages DeepL
      supports (with the exception of Thai).
  - name: MetaInformation
    description: Information about API usage and value ranges
  - name: TranslationMemories
    description: >-
      The translation memory endpoints allow you to manage your account's
      translation memories, used to store

      and reuse previously created translations. You can list and retrieve
      translation memories, page through

      their stored segments, create one by importing a TMX file, export one back
      to TMX, and delete one.

      Editing the contents of an existing translation memory is not supported;
      import a new one instead.


      Importing and exporting run as background jobs. Create the job, then poll

      `GET /v3/translation_memories/jobs/{job_id}` until it reports `completed`.


      Translation memories can be used in text translation requests by

      specifying the `translation_memory_id` parameter to denote a specific
      translation memory and the

      `translation_memory_threshold` which defines the minimum matching
      percentage required for a translation memory

      segment to be applied (recommended to be 75% or higher). A translation
      request fails with `404` if the

      translation memory does not exist or does not cover the requested language
      pair.
  - name: VoiceAPI
    description: >-
      The Voice API provides real-time voice transcription and translation
      services.

      Use a two-step flow: first request a streaming URL via REST, then
      establish a WebSocket connection for streaming audio and receiving
      transcriptions.
  - name: VoiceTranslateJob
    description: >-
      **Alpha.** Async voice translation jobs. This API may change without
      notice.
  - name: AdminApi
    description: >-
      Endpoints for organization administrators to manage API keys and retrieve
      usage analytics.
  - name: QualityEvaluation
    description: >-
      **Closed alpha.** Evaluate translation quality. Submit source/target
      segment pairs and retrieve per-segment quality issues categorized by error
      type and severity, with character spans pointing to where each issue
      occurs.
externalDocs:
  description: DeepL Pro - Plans and pricing
  url: https://www.deepl.com/pro#developer
paths:
  /v3/translation_memories/{translation_memory_id}/segments:
    get:
      tags:
        - TranslationMemories
      summary: List translation memory segments
      description: >-
        List the segments stored in a translation memory, one page at a time.
        Each entry is a source

        segment with its translations in every target language.


        This endpoint uses cursor-based pagination rather than the numbered
        pages used by

        [List translation
        memories](/api-reference/translation-memory/list-translation-memories).
        Omit

        `page_cursor` on your first call, then pass the `next_page_cursor` from
        each response to get the

        following page. When a response has no `next_page_cursor`, you have
        reached the last page.


        Requires an API key with the `translation_memories:read` scope.
      operationId: getTranslationMemorySegments
      parameters:
        - name: translation_memory_id
          in: path
          required: true
          schema:
            $ref: '#/components/schemas/TranslationMemoryId'
          description: The ID of the translation memory whose segments you want to list.
        - name: page_size
          in: query
          schema:
            type: integer
            default: 50
            minimum: 1
            maximum: 100
          description: >-
            The maximum number of segments to return per page. Values above 100
            are reduced to 100.
        - name: page_cursor
          in: query
          schema:
            type: string
          description: >-
            The `next_page_cursor` from a previous response. Omit this on your
            first call. Treat the value

            as opaque: do not build or modify it yourself.
        - name: filter_text
          in: query
          schema:
            type: string
            minLength: 2
          description: >-
            Return only segments where this text appears in the source or in any
            target translation. Must be

            at least 2 characters.
        - name: filter_case_sensitive
          in: query
          schema:
            type: boolean
            default: false
          description: Whether `filter_text` is matched case-sensitively.
      responses:
        '200':
          description: Returns a page of segments.
          headers:
            X-Trace-ID:
              $ref: '#/components/headers/X-Trace-ID'
          content:
            application/json:
              schema:
                type: object
                required:
                  - segments
                  - segment_count
                properties:
                  segments:
                    description: The segments on this page.
                    type: array
                    items:
                      $ref: '#/components/schemas/TranslationMemorySegment'
                  segment_count:
                    description: >-
                      The total number of segments in the translation memory.
                      This is not reduced by

                      `filter_text`, so a filtered request still reports the
                      full count. Do not use it to

                      predict how many results a filtered query returns.
                    type: integer
                    example: 3542
                  next_page_cursor:
                    description: >-
                      The cursor to pass as `page_cursor` to retrieve the next
                      page. Absent on the last page.
                    type: string
                    example: eyJvZmZzZXQiOjUwfQ
              examples:
                Basic:
                  value:
                    segments:
                      - source_segment_id: 4f1c2d3e-8a9b-4c5d-9e6f-7a8b9c0d1e2f
                        source_text: This agreement is governed by the laws of Germany.
                        creation_time: '2026-04-01T16:34:25.223Z'
                        updated_time: '2026-04-01T16:34:25.223Z'
                        last_used_time: '2026-08-05T11:02:18.771Z'
                        targets:
                          - target_segment_id: 9b8a7c6d-5e4f-4a3b-8c2d-1e0f9a8b7c6d
                            target_language: de
                            target_text: >-
                              Dieser Vertrag unterliegt dem Recht der
                              Bundesrepublik Deutschland.
                            creation_time: '2026-04-01T16:34:25.223Z'
                            updated_time: '2026-04-01T16:34:25.223Z'
                            last_used_time: '2026-08-05T11:02:18.771Z'
                          - target_segment_id: 2c3d4e5f-6a7b-4c8d-9e0f-1a2b3c4d5e6f
                            target_language: es
                            target_text: Este contrato se rige por las leyes de Alemania.
                            creation_time: '2026-04-01T16:34:25.223Z'
                            updated_time: '2026-04-01T16:34:25.223Z'
                            last_used_time: '2026-07-22T08:41:05.330Z'
                    segment_count: 3542
                    next_page_cursor: eyJvZmZzZXQiOjUwfQ
                Last page:
                  value:
                    segments:
                      - source_segment_id: 7a8b9c0d-1e2f-4a3b-8c4d-5e6f7a8b9c0d
                        source_text: Termination requires 30 days written notice.
                        creation_time: '2026-04-01T16:34:25.223Z'
                        updated_time: '2026-04-01T16:34:25.223Z'
                        last_used_time: '2026-08-01T14:20:09.512Z'
                        targets:
                          - target_segment_id: 0d1e2f3a-4b5c-4d6e-8f7a-8b9c0d1e2f3a
                            target_language: de
                            target_text: >-
                              Die Kündigung erfordert eine schriftliche Frist
                              von 30 Tagen.
                            creation_time: '2026-04-01T16:34:25.223Z'
                            updated_time: '2026-04-01T16:34:25.223Z'
                            last_used_time: '2026-08-01T14:20:09.512Z'
                    segment_count: 3542
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/ForbiddenScoped'
        '404':
          description: >-
            The translation memory could not be found. This is also returned for
            a translation memory that

            belongs to another account.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '429':
          $ref: '#/components/responses/TooManyRequests'
        '500':
          $ref: '#/components/responses/InternalServerError'
        '503':
          $ref: '#/components/responses/ServiceUnavailable'
      security:
        - auth_header: []
components:
  schemas:
    TranslationMemoryId:
      type: string
      format: uuid
      description: A unique ID assigned to a translation memory.
      example: a74d88fb-ed2a-4943-a664-a4512398b994
    TranslationMemorySegment:
      description: A source segment stored in a translation memory, with its translations.
      type: object
      required:
        - source_segment_id
        - source_text
        - targets
      properties:
        source_segment_id:
          description: A unique ID assigned to the source segment.
          type: string
          example: 4f1c2d3e-8a9b-4c5d-9e6f-7a8b9c0d1e2f
        source_text:
          description: The source text of the segment.
          type: string
          example: This agreement is governed by the laws of Germany.
        creation_time:
          description: The time the segment was added, in the ISO 8601-1:2019 format.
          type: string
          format: date-time
          example: '2026-04-01T16:34:25.223Z'
        updated_time:
          description: >-
            The time the segment was last changed, in the ISO 8601-1:2019
            format.
          type: string
          format: date-time
          example: '2026-04-01T16:34:25.223Z'
        last_used_time:
          description: >-
            The time the segment was last applied to a translation, in the ISO
            8601-1:2019 format. Absent

            if the segment has never been used.
          type: string
          format: date-time
          example: '2026-08-05T11:02:18.771Z'
        targets:
          description: The translations of this source segment, one per target language.
          type: array
          items:
            $ref: '#/components/schemas/TranslationMemoryTargetSegment'
    ErrorResponse:
      type: object
      required:
        - message
      properties:
        message:
          type: string
          description: A human-readable description of the error.
        code:
          type: string
          description: >-
            A machine-readable identifier for the error, when available. Clients
            should match on this value rather than on `message` when branching
            on error types.
          example: invalid_content_type
    TranslationMemoryTargetSegment:
      description: A translation of a source segment in one target language.
      type: object
      required:
        - target_segment_id
        - target_language
        - target_text
      properties:
        target_segment_id:
          description: A unique ID assigned to the target segment.
          type: string
          example: 9b8a7c6d-5e4f-4a3b-8c2d-1e0f9a8b7c6d
        target_language:
          $ref: '#/components/schemas/TranslationMemoryTargetLanguage'
        target_text:
          description: The translated text.
          type: string
          example: Dieser Vertrag unterliegt dem Recht der Bundesrepublik Deutschland.
        creation_time:
          description: The time the translation was added, in the ISO 8601-1:2019 format.
          type: string
          format: date-time
          example: '2026-04-01T16:34:25.223Z'
        updated_time:
          description: >-
            The time the translation was last changed, in the ISO 8601-1:2019
            format.
          type: string
          format: date-time
          example: '2026-04-01T16:34:25.223Z'
        last_used_time:
          description: >-
            The time the translation was last applied to a translation request,
            in the ISO 8601-1:2019

            format. Absent if it has never been used.
          type: string
          format: date-time
          example: '2026-08-05T11:02:18.771Z'
    TranslationMemoryTargetLanguage:
      description: >-
        The list of target languages available in the translation memory. A
        translation memory's target language must be compatible with the
        `target_lang` specified in a translation request.
      type: string
      enum:
        - de
        - en
        - en-gb
        - en-us
        - es
        - es-419
        - fr
        - it
        - ja
        - ko
        - zh
        - zh-hans
      example: es
  headers:
    X-Trace-ID:
      description: >-
        A unique identifier for the request that can be included in bug reports
        to DeepL support.
      schema:
        type: string
      example: 501c3d93cc0c4f11ae2f60a226c2f0f0
  responses:
    BadRequest:
      description: Bad request. Please check error message and your parameters.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
    Unauthorized:
      description: >-
        Authorization failed. Please supply a valid `DeepL-Auth-Key` via the
        `Authorization` header.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
    ForbiddenScoped:
      description: >-
        Authorization failed. Please supply a valid `DeepL-Auth-Key` via the
        `Authorization` header. This error is also returned when the API key is
        scoped but does not include the scope required for this endpoint.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
    TooManyRequests:
      description: Too many requests. Please wait and resend your request.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
    InternalServerError:
      description: Internal error.
    ServiceUnavailable:
      description: Resource currently unavailable. Try again later.
  securitySchemes:
    auth_header:
      type: apiKey
      description: >
        Authentication with `Authorization` header and `DeepL-Auth-Key`
        authentication scheme. Example: `DeepL-Auth-Key <api-key>`
      name: Authorization
      in: header
      x-default: 'DeepL-Auth-Key '

````