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

# List tasks V1

> Retrieves a list of tasks using the v1 endpoint.

Use `getTasks` instead.

**Required ACL:** `addObject`, `deleteIndex`, `editSettings`


## OpenAPI

````yaml specs/ingestion.yml get /1/tasks
openapi: 3.1.0
info:
  title: Ingestion API
  summary: >-
    The Ingestion API lets you connect third-party services and platforms with
    Algolia and schedule tasks to ingest your data
  description: >
    The Ingestion API powers the no-code [data
    connectors](https://dashboard.algolia.com/connectors).


    ## Base URLs


    Base URLs for the Ingestion API:


    - `https://data.us.algolia.com`

    - `https://data.eu.algolia.com`


    Use the URL that matches your [analytics
    region](https://dashboard.algolia.com/account/infrastructure/analytics).


    **All requests must use HTTPS.**


    ## Authentication


    Add these headers to authenticate requests:


    - `x-algolia-application-id`. Your Algolia application ID.

    - `x-algolia-api-key`. An API key with the necessary permissions to make the
    request.
      The required access control list (ACL) to make a request is listed in each endpoint's reference.

    You can find your application ID and API key in the [Algolia
    dashboard](https://dashboard.algolia.com/account/api-keys).


    ## Request format


    Request bodies must be JSON objects.


    ## Response status and errors


    Response bodies are JSON objects.


    Successful responses return `2xx` statuses. Client errors return `4xx`
    statuses. Server errors return `5xx` statuses.

    Error responses have a `message` property with more information.


    ## Version


    The current version of the Ingestion API is version 1, indicated by the
    `/1/` in each endpoint's URL.
  version: 1.0.0
servers:
  - url: https://data.{region}.algolia.com
    variables:
      region:
        description: The region where your Algolia application is hosted.
        enum:
          - eu
          - us
        default: us
security:
  - appId: []
    apiKey: []
tags:
  - name: authentications
    x-displayName: Authentications
    description: >-
      Authentication resources describe how to connect to a source or
      destination.
  - name: destinations
    x-displayName: Destinations
    description: >
      Destinations are Algolia products or features where your data should be
      used, such as a search index or events.

      Algolia destinations require authentication with the `algolia` type.

      You can reference authentications by their ID when creating destinations.
  - name: observability
    x-displayName: Observability
    description: >-
      Check the status and details of your task runs. A run is one instance of a
      configured task.
  - name: sources
    x-displayName: Sources
    description: >
      Sources are third-party platforms or services from where you want to
      ingest your data.

      Sources may require authentication. To interact with such sources, you can
      reference an authentication resource by its ID.
  - name: tasks
    x-displayName: Tasks
    description: >
      Tasks contain information how your data should be read from a source and
      stored in a destination.

      Tasks have _triggers_ which determine when the task should run.
  - name: transformations
    x-displayName: Transformations
    description: >
      Transformations let you transform a record before it gets indexed in
      Algolia.
paths:
  /1/tasks:
    get:
      tags:
        - tasks
      summary: List tasks V1
      description: Retrieves a list of tasks using the v1 endpoint. Use `getTasks` instead.
      operationId: listTasksV1
      parameters:
        - $ref: '#/components/parameters/action'
        - $ref: '#/components/parameters/destinationID'
        - $ref: '#/components/parameters/enabled'
        - $ref: '#/components/parameters/itemsPerPage'
        - $ref: '#/components/parameters/order'
        - $ref: '#/components/parameters/page'
        - $ref: '#/components/parameters/taskParameters_sort'
        - $ref: '#/components/parameters/sourceID'
        - $ref: '#/components/parameters/triggerType'
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                title: listTasksResponseV1
                type: object
                description: Configured tasks and pagination information.
                additionalProperties: false
                properties:
                  pagination:
                    $ref: '#/components/schemas/Pagination'
                  tasks:
                    type: array
                    items:
                      $ref: '#/components/schemas/TaskV1'
                required:
                  - tasks
                  - pagination
        '400':
          $ref: '#/components/responses/BadRequest'
      deprecated: true
      x-codeSamples:
        - lang: csharp
          label: C#
          source: |-
            // Initialize the client
            var client = new IngestionClient(
              new IngestionConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION")
            );

            // Call the API
            var response = await client.ListTasksV1Async();

            // print the response
            Console.WriteLine(response);
        - lang: dart
          label: Dart
          source: |-
            // Initialize the client
            final client = IngestionClient(
                appId: 'ALGOLIA_APPLICATION_ID',
                apiKey: 'ALGOLIA_API_KEY',
                region: 'ALGOLIA_APPLICATION_REGION');

            // Call the API
            final response = await client.listTasksV1();

            // print the response
            print(response);
        - lang: go
          label: Go
          source: >-
            // Initialize the client with your application region, eg.
            ingestion.ALGOLIA_APPLICATION_REGION

            client, err := ingestion.NewClient("ALGOLIA_APPLICATION_ID",
            "ALGOLIA_API_KEY", ingestion.US)

            if err != nil {
              // The client can fail to initialize if you pass an invalid parameter.
              panic(err)
            }


            // Call the API

            response, err :=
            client.ListTasksV1(client.NewApiListTasksV1Request())

            if err != nil {
              // handle the eventual error
              panic(err)
            }



            // print the response

            print(response)
        - lang: java
          label: Java
          source: >-
            // Initialize the client

            IngestionClient client = new
            IngestionClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY",
            "ALGOLIA_APPLICATION_REGION");


            // Call the API

            ListTasksResponseV1 response = client.listTasksV1();


            // print the response

            System.out.println(response);
        - lang: javascript
          label: JavaScript
          source: >-
            // Initialize the client

            // Replace 'us' with your Algolia Application Region

            const client = algoliasearch('ALGOLIA_APPLICATION_ID',
            'ALGOLIA_API_KEY').initIngestion({ region: 'us' });


            // Call the API

            const response = await client.listTasksV1();



            // print the response

            console.log(response);
        - lang: kotlin
          label: Kotlin
          source: |-
            // Initialize the client
            val client =
              IngestionClient(
                appId = "ALGOLIA_APPLICATION_ID",
                apiKey = "ALGOLIA_API_KEY",
                region = "ALGOLIA_APPLICATION_REGION",
              )

            // Call the API
            var response = client.listTasksV1()


            // print the response
            println(response)
        - lang: php
          label: PHP
          source: >-
            // Initialize the client

            $client = IngestionClient::create('ALGOLIA_APPLICATION_ID',
            'ALGOLIA_API_KEY', 'ALGOLIA_APPLICATION_REGION');


            // Call the API

            $response = $client->listTasksV1();



            // print the response

            var_dump($response);
        - lang: python
          label: Python
          source: >-
            # Initialize the client

            # In an asynchronous context, you can use IngestionClient instead,
            which exposes the exact same methods.

            client = IngestionClientSync(
                "ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION"
            )


            # Call the API

            response = client.list_tasks_v1()



            # print the response

            print(response)
        - lang: ruby
          label: Ruby
          source: >-
            # Initialize the client

            client = Algolia::IngestionClient.create("ALGOLIA_APPLICATION_ID",
            "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION")


            # Call the API

            response = client.list_tasks_v1



            # print the response

            puts(response)
        - lang: scala
          label: Scala
          source: |-
            // Initialize the client
            val client = IngestionClient(
              appId = "ALGOLIA_APPLICATION_ID",
              apiKey = "ALGOLIA_API_KEY",
              region = "ALGOLIA_APPLICATION_REGION"
            )

            // Call the API
            val response = Await.result(
              client.listTasksV1(
              ),
              Duration(100, "sec")
            )

            // print the response
            println(response)
        - lang: swift
          label: Swift
          source: >-
            // Initialize the client

            let client = try IngestionClient(appID: "ALGOLIA_APPLICATION_ID",
            apiKey: "ALGOLIA_API_KEY", region: .us)


            // Call the API

            let response = try await client.listTasksV1()


            // print the response

            print(response)
        - lang: cURL
          label: curl
          source: |-
            curl --request GET \
              --url 'https://data.us.algolia.com/1/tasks?itemsPerPage=10&page=1&action=save%2Creplace%2Cpartial%2Cappend&enabled=true&sourceID=6c02aeb1-775e-418e-870b-1faccd4b2c0f&destinationID=6c02aeb1-775e-418e-870b-1faccd4b2c0f&triggerType=onDemand%2Cschedule%2Csubscription%2Cstreaming&sort=createdAt&order=desc' \
              --header 'accept: application/json' \
              --header 'x-algolia-api-key: ALGOLIA_API_KEY' \
              --header 'x-algolia-application-id: ALGOLIA_APPLICATION_ID'
components:
  parameters:
    action:
      name: action
      in: query
      required: false
      description: Actions for filtering the list of tasks.
      style: form
      explode: false
      schema:
        type: array
        description: Actions to perform on the Algolia index.
        items:
          $ref: '#/components/schemas/ActionType'
        example: save,replace,partial,append
    destinationID:
      name: destinationID
      in: query
      description: Destination IDs for filtering the list of tasks.
      required: false
      style: form
      explode: false
      schema:
        type: array
        items:
          $ref: '#/components/schemas/destinationID'
    enabled:
      name: enabled
      in: query
      description: Whether to filter the list of tasks by the `enabled` status.
      required: false
      schema:
        type: boolean
    itemsPerPage:
      name: itemsPerPage
      in: query
      description: Number of items per page.
      required: false
      schema:
        $ref: '#/components/schemas/itemsPerPage'
    order:
      name: order
      in: query
      description: Sort order of the response, ascending or descending.
      required: false
      schema:
        $ref: '#/components/schemas/orderKeys'
    page:
      name: page
      in: query
      description: Page number of the paginated API response.
      required: false
      schema:
        $ref: '#/components/schemas/page'
    taskParameters_sort:
      name: sort
      in: query
      description: Property by which to sort the list of tasks.
      required: false
      schema:
        $ref: '#/components/schemas/taskSortKeys'
    sourceID:
      name: sourceID
      in: query
      description: Source IDs for filtering the list of tasks.
      required: false
      style: form
      explode: false
      schema:
        type: array
        items:
          $ref: '#/components/schemas/sourceID'
    triggerType:
      name: triggerType
      in: query
      description: Type of task trigger for filtering the list of tasks.
      required: false
      style: form
      explode: false
      schema:
        type: array
        items:
          $ref: '#/components/schemas/TriggerType'
        example: onDemand,schedule,subscription,streaming
  schemas:
    Pagination:
      type: object
      description: Paginated API response.
      additionalProperties: false
      properties:
        itemsPerPage:
          $ref: '#/components/schemas/itemsPerPage'
        nbItems:
          type: integer
          minimum: 0
          description: Number of items in the API response.
        nbPages:
          type: integer
          minimum: 1
          description: Number of pages in the API response.
        page:
          $ref: '#/components/schemas/page'
      required:
        - nbPages
        - page
        - nbItems
        - itemsPerPage
    TaskV1:
      type: object
      additionalProperties: false
      deprecated: true
      description: >-
        The V1 task object. Use methods and types that don't contain the V1
        suffix.
      properties:
        createdAt:
          $ref: '#/components/schemas/CreatedAt'
        destinationID:
          $ref: '#/components/schemas/destinationID'
        enabled:
          type: boolean
          default: true
          description: Whether the task is enabled.
        sourceID:
          $ref: '#/components/schemas/sourceID'
        taskID:
          $ref: '#/components/schemas/taskID'
        trigger:
          $ref: '#/components/schemas/Trigger'
        updatedAt:
          $ref: '#/components/schemas/updatedAt'
        action:
          $ref: '#/components/schemas/ActionType'
        cursor:
          $ref: '#/components/schemas/cursor'
        failureThreshold:
          $ref: '#/components/schemas/failureThreshold'
        input:
          $ref: '#/components/schemas/TaskInput'
        notifications:
          $ref: '#/components/schemas/Notifications'
        policies:
          $ref: '#/components/schemas/Policies'
      required:
        - taskID
        - sourceID
        - destinationID
        - trigger
        - enabled
        - createdAt
        - updatedAt
    ActionType:
      type: string
      description: Action to perform on the Algolia index.
      enum:
        - replace
        - save
        - partial
        - partialNoCreate
        - append
    destinationID:
      type: string
      description: Universally unique identifier (UUID) of a destination resource.
      example: 6c02aeb1-775e-418e-870b-1faccd4b2c0f
    itemsPerPage:
      type: integer
      description: Number of items per page.
      minimum: 1
      maximum: 100
      default: 10
    orderKeys:
      type: string
      description: Ascending or descending sort order.
      default: desc
      enum:
        - asc
        - desc
    page:
      type: integer
      minimum: 1
      description: Page of the API response to retrieve.
    taskSortKeys:
      type: string
      description: Property by which to sort the list of tasks.
      default: createdAt
      enum:
        - enabled
        - triggerType
        - action
        - updatedAt
        - createdAt
    sourceID:
      type: string
      description: Universally uniqud identifier (UUID) of a source.
      example: 6c02aeb1-775e-418e-870b-1faccd4b2c0f
    TriggerType:
      type: string
      description: |
        Task trigger, describing when a task should run.

        - `onDemand`.
          Manually trigger the task with the `/run` endpoint.

        - `schedule`.
          Regularly trigger the task on a `cron` schedule.

        - `subscription`.
          Trigger the task after an event is received, such as, a webhook.

        - `streaming`.
          Run the task continuously.
      enum:
        - onDemand
        - schedule
        - subscription
        - streaming
    CreatedAt:
      type: string
      description: Date and time when the resource was created, in RFC 3339 format.
    taskID:
      type: string
      description: Universally unique identifier (UUID) of a task.
      example: 6c02aeb1-775e-418e-870b-1faccd4b2c0f
    Trigger:
      description: Trigger that runs the task.
      oneOf:
        - $ref: '#/components/schemas/OnDemandTrigger'
        - $ref: '#/components/schemas/ScheduleTrigger'
        - $ref: '#/components/schemas/SubscriptionTrigger'
        - $ref: '#/components/schemas/StreamingTrigger'
    updatedAt:
      type: string
      description: Date and time when the resource was last updated, in RFC 3339 format.
    cursor:
      type: string
      description: Date and time when the last cursor was created, in RFC 3339 format.
    failureThreshold:
      type: integer
      minimum: 0
      maximum: 100
      description: >-
        Maximum accepted percentage of failures for a task run to finish
        successfully.
    TaskInput:
      description: Configuration of the task, depending on its type.
      oneOf:
        - $ref: '#/components/schemas/StreamingInput'
        - $ref: '#/components/schemas/DockerStreamsInput'
        - $ref: '#/components/schemas/ShopifyInput'
    Notifications:
      type: object
      additionalProperties: false
      description: Notifications settings for a task.
      properties:
        email:
          title: emailNotifications
          type: object
          additionalProperties: false
          properties:
            enabled:
              description: >-
                Whether to send email notifications, note that this doesn't
                prevent the task from being blocked.
              type: boolean
      required:
        - email
    Policies:
      type: object
      additionalProperties: false
      description: Set of rules for a task.
      properties:
        criticalThreshold:
          description: >-
            The number of critical failures in a row before blocking the task
            and sending a notification.
          type: integer
          minimum: 1
          maximum: 10
    ErrorBase:
      description: Error.
      type: object
      x-keep-model: true
      additionalProperties: true
      properties:
        message:
          type: string
          example: Invalid Application-Id or API-Key
    OnDemandTrigger:
      type: object
      additionalProperties: false
      description: Trigger information for manually-triggered tasks.
      properties:
        type:
          $ref: '#/components/schemas/OnDemandTriggerType'
        lastRun:
          $ref: '#/components/schemas/LastRun'
      required:
        - type
    ScheduleTrigger:
      type: object
      additionalProperties: false
      description: Trigger information for scheduled tasks.
      properties:
        cron:
          $ref: '#/components/schemas/Cron'
        nextRun:
          $ref: '#/components/schemas/NextRun'
        type:
          $ref: '#/components/schemas/ScheduleTriggerType'
        lastRun:
          $ref: '#/components/schemas/LastRun'
      required:
        - type
        - cron
        - nextRun
    SubscriptionTrigger:
      type: object
      additionalProperties: false
      description: Trigger input for subscription tasks.
      properties:
        type:
          $ref: '#/components/schemas/SubscriptionTriggerType'
      required:
        - type
    StreamingTrigger:
      type: object
      additionalProperties: false
      description: Trigger input for continuously running tasks.
      properties:
        type:
          $ref: '#/components/schemas/StreamingTriggerType'
      required:
        - type
    StreamingInput:
      title: Streaming input
      type: object
      additionalProperties: false
      description: >-
        Input for a `streaming` task whose source is of type `ga4BigqueryExport`
        and for which extracted data is continuously streamed.
      properties:
        mapping:
          $ref: '#/components/schemas/MappingInput'
      required:
        - mapping
      x-discriminator-fields:
        - mapping
    DockerStreamsInput:
      title: Docker streams
      description: The selected streams of an airbyte connector.
      type: object
      properties:
        streams:
          type: array
          items:
            $ref: '#/components/schemas/DockerStreams'
      required:
        - streams
      x-discriminator-fields:
        - streams
    ShopifyInput:
      title: Shopify input
      type: object
      additionalProperties: false
      description: >-
        Represents the required elements of the task input when using a
        `shopify` source.
      properties:
        market:
          $ref: '#/components/schemas/ShopifyMarket'
        metafields:
          type: array
          items:
            $ref: '#/components/schemas/ShopifyMetafield'
      required:
        - metafields
        - market
    OnDemandTriggerType:
      type: string
      description: Task is run manually, with the `/run` endpoint.
      enum:
        - onDemand
    LastRun:
      description: The last time the scheduled task ran in RFC 3339 format.
      type: string
    Cron:
      type: string
      description: Cron expression for the task's schedule.
      example: '* * 1 * *'
    NextRun:
      description: The next scheduled run of the task in RFC 3339 format.
      type: string
    ScheduleTriggerType:
      type: string
      description: Task runs on a schedule.
      enum:
        - schedule
    SubscriptionTriggerType:
      type: string
      description: Task runs after receiving subscribed event.
      enum:
        - subscription
    StreamingTriggerType:
      type: string
      description: Task runs continuously.
      enum:
        - streaming
    MappingInput:
      type: object
      additionalProperties: false
      description: Transformations to apply to the source, serialized as a JSON string.
      properties:
        actions:
          type: array
          items:
            $ref: '#/components/schemas/MappingKitAction'
        format:
          $ref: '#/components/schemas/MappingFormatSchema'
      required:
        - format
        - actions
      x-discriminator-fields:
        - format
        - actions
    DockerStreams:
      type: object
      properties:
        name:
          type: string
          description: The name of the stream to fetch the data from (e.g. table name).
        syncMode:
          $ref: '#/components/schemas/DockerStreamsSyncMode'
        properties:
          type: array
          description: The properties of the stream to select (e.g. column).
          items:
            type: string
      required:
        - name
        - syncMode
    ShopifyMarket:
      type: object
      additionalProperties: false
      description: Represents a market in Shopify.
      properties:
        countries:
          type: array
          items:
            type: string
        currencies:
          type: array
          items:
            type: string
        locales:
          type: array
          items:
            type: string
      required:
        - countries
        - currencies
        - locales
    ShopifyMetafield:
      type: object
      additionalProperties: false
      description: Represents a metafield in Shopify.
      properties:
        key:
          type: string
        namespace:
          type: string
        value:
          type: string
      required:
        - namespace
        - key
        - value
    MappingKitAction:
      type: object
      additionalProperties: false
      description: >-
        Describes how a destination object should be resolved by means of
        applying a set of directives.
      properties:
        enabled:
          description: Whether this action has any effect.
          type: boolean
        fieldDirectives:
          type: array
          items:
            $ref: '#/components/schemas/MappingFieldDirective'
        trigger:
          description: >-
            Condition which must be satisfied to apply the action. If this
            evaluates to false, the action is not applied, and the process
            attempts to apply the next action, if any.
          type: string
        id:
          description: ID to uniquely identify this action.
          type: string
      required:
        - enabled
        - trigger
        - fieldDirectives
    MappingFormatSchema:
      type: string
      description: Mapping format schema.
      enum:
        - mappingkit/v1
    DockerStreamsSyncMode:
      type: string
      description: The strategy to use to fetch the data.
      enum:
        - incremental
        - fullTable
    MappingFieldDirective:
      type: object
      additionalProperties: false
      description: >-
        Describes how a field should be resolved by applying a set of
        directives.
      properties:
        fieldKey:
          description: Destination field key.
          type: string
        value:
          type: object
          additionalProperties: true
          description: How the destination field should be resolved from the source.
      required:
        - fieldKey
        - value
  responses:
    BadRequest:
      description: Bad request or request arguments.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorBase'
  securitySchemes:
    appId:
      type: apiKey
      in: header
      name: x-algolia-application-id
      description: Your Algolia application ID.
    apiKey:
      type: apiKey
      in: header
      name: x-algolia-api-key
      description: >
        Your Algolia API key with the necessary permissions to make the request.

        Permissions are controlled through access control lists (ACL) and access
        restrictions.

        The required ACL to make a request is listed in each endpoint's
        reference.

````