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

# Update a task V1

> Updates a task by its ID using the v1 endpoint.

Use `updateTask` instead.

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


## OpenAPI

````yaml specs/ingestion.yml patch /1/tasks/{taskID}
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/{taskID}:
    patch:
      tags:
        - tasks
      summary: Update a task V1
      description: >-
        Updates a task by its ID using the v1 endpoint. Use `updateTask`
        instead.
      operationId: updateTaskV1
      parameters:
        - $ref: '#/components/parameters/pathTaskID'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/TaskUpdateV1'
        required: true
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TaskUpdateResponse'
        '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.UpdateTaskV1Async(
              "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
              new TaskUpdateV1 { Enabled = false }
            );

            // 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.updateTaskV1(
              taskID: "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
              taskUpdate: TaskUpdateV1(
                enabled: false,
              ),
            );

            // 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.UpdateTaskV1(client.NewApiUpdateTaskV1Request(
              "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
              ingestion.NewEmptyTaskUpdateV1().SetEnabled(false)))
            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

            TaskUpdateResponse response =
            client.updateTaskV1("6c02aeb1-775e-418e-870b-1faccd4b2c0f", new
            TaskUpdateV1().setEnabled(false));


            // 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.updateTaskV1({
              taskID: '6c02aeb1-775e-418e-870b-1faccd4b2c0f',
              taskUpdate: { enabled: false },
            });



            // 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.updateTaskV1(
                taskID = "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
                taskUpdate = TaskUpdateV1(enabled = false),
              )


            // 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->updateTaskV1(
                '6c02aeb1-775e-418e-870b-1faccd4b2c0f',
                ['enabled' => false,
                ],
            );



            // 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.update_task_v1(
                task_id="6c02aeb1-775e-418e-870b-1faccd4b2c0f",
                task_update={
                    "enabled": False,
                },
            )



            # 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.update_task_v1(
              "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
              Algolia::Ingestion::TaskUpdateV1.new(enabled: false)
            )



            # 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.updateTaskV1(
                taskID = "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
                taskUpdate = TaskUpdateV1(
                  enabled = Some(false)
                )
              ),
              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.updateTaskV1(
                taskID: "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
                taskUpdate: TaskUpdateV1(enabled: false)
            )


            // print the response

            print(response)
        - lang: cURL
          label: curl
          source: |-
            curl --request PATCH \
              --url https://data.us.algolia.com/1/tasks/6c02aeb1-775e-418e-870b-1faccd4b2c0f \
              --header 'accept: application/json' \
              --header 'content-type: application/json' \
              --header 'x-algolia-api-key: ALGOLIA_API_KEY' \
              --header 'x-algolia-application-id: ALGOLIA_APPLICATION_ID' \
              --data '
            {
              "destinationID": "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
              "trigger": {
                "cron": "* * 1 * *"
              },
              "input": {
                "mapping": {
                  "format": "mappingkit/v1",
                  "actions": [
                    {
                      "id": "lorem",
                      "enabled": true,
                      "trigger": "lorem",
                      "fieldDirectives": [
                        {
                          "fieldKey": "lorem",
                          "value": {}
                        }
                      ]
                    }
                  ]
                }
              },
              "enabled": true,
              "failureThreshold": 0
            }
            '
components:
  parameters:
    pathTaskID:
      name: taskID
      in: path
      required: true
      description: Unique identifier of a task.
      schema:
        $ref: '#/components/schemas/taskID'
  schemas:
    TaskUpdateV1:
      type: object
      additionalProperties: false
      deprecated: true
      description: >-
        API request body for updating a task using the V1 shape. Use methods and
        types that don't contain the V1 suffix.
      properties:
        destinationID:
          $ref: '#/components/schemas/destinationID'
        enabled:
          $ref: '#/components/schemas/Enabled'
        failureThreshold:
          $ref: '#/components/schemas/failureThreshold'
        input:
          $ref: '#/components/schemas/TaskInput'
        trigger:
          $ref: '#/components/schemas/TriggerUpdateInput'
    TaskUpdateResponse:
      type: object
      description: API response for updating a task.
      additionalProperties: false
      properties:
        taskID:
          $ref: '#/components/schemas/taskID'
        updatedAt:
          $ref: '#/components/schemas/updatedAt'
      required:
        - taskID
        - updatedAt
    taskID:
      type: string
      description: Universally unique identifier (UUID) of a task.
      example: 6c02aeb1-775e-418e-870b-1faccd4b2c0f
    destinationID:
      type: string
      description: Universally unique identifier (UUID) of a destination resource.
      example: 6c02aeb1-775e-418e-870b-1faccd4b2c0f
    Enabled:
      type: boolean
      description: Whether the task is enabled.
    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'
    TriggerUpdateInput:
      type: object
      additionalProperties: false
      description: Trigger for a task update.
      properties:
        cron:
          $ref: '#/components/schemas/Cron'
      required:
        - cron
    updatedAt:
      type: string
      description: Date and time when the resource was last updated, in RFC 3339 format.
    ErrorBase:
      description: Error.
      type: object
      x-keep-model: true
      additionalProperties: true
      properties:
        message:
          type: string
          example: Invalid Application-Id or API-Key
    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
    Cron:
      type: string
      description: Cron expression for the task's schedule.
      example: '* * 1 * *'
    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.

````