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

# Add or update a composition rule

> If a composition rule with the provided ID already exists, it's replaced.

**Required ACL:** `editSettings`

Otherwise, a new one is added.

## Usage

<CodeGroup>
  ```cs C# theme={"system"}
  // Initialize the client
  var client = new CompositionClient(
    new CompositionConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
  );

  // Call the API
  var response = await client.PutCompositionRuleAsync(
    "compositionID",
    "rule-with-deduplication",
    new CompositionRule
    {
      ObjectID = "rule-with-deduplication",
      Description = "my description",
      Enabled = true,
      Conditions = new List<Condition>
      {
        new Condition { Anchoring = Enum.Parse<Anchoring>("Contains"), Pattern = "harry" },
      },
      Consequence = new CompositionRuleConsequence
      {
        Behavior = new CompositionBehavior(
          new CompositionInjectionBehavior
          {
            Injection = new Injection
            {
              Main = new InjectionMain
              {
                Source = new InjectionMainSource(
                  new InjectionMainSearchSource { Search = new MainSearch { Index = "my-index" } }
                ),
              },
              InjectedItems = new List<InjectionInjectedItem>
              {
                new InjectionInjectedItem
                {
                  Key = "my-unique-injected-item-key",
                  Source = new InjectedItemSource(
                    new InjectedItemSearchSource
                    {
                      Search = new InjectedItemSearch { Index = "my-index" },
                    }
                  ),
                  Position = 0,
                  Length = 3,
                },
              },
              Deduplication = new Deduplication
              {
                Positioning = Enum.Parse<DedupPositioning>("HighestInjected"),
              },
            },
          }
        ),
      },
    }
  );

  // print the response
  Console.WriteLine(response);
  ```

  ```dart Dart theme={"system"}
  // Initialize the client
  final client = CompositionClient(
      appId: 'ALGOLIA_APPLICATION_ID', apiKey: 'ALGOLIA_API_KEY');

  // Call the API
  final response = await client.putCompositionRule(
    compositionID: "compositionID",
    objectID: "rule-with-deduplication",
    compositionRule: CompositionRule(
      objectID: "rule-with-deduplication",
      description: "my description",
      enabled: true,
      conditions: [
        Condition(
          anchoring: Anchoring.fromJson("contains"),
          pattern: "harry",
        ),
      ],
      consequence: CompositionRuleConsequence(
        behavior: CompositionInjectionBehavior(
          injection: Injection(
            main: InjectionMain(
              source: InjectionMainSearchSource(
                search: MainSearch(
                  index: "my-index",
                ),
              ),
            ),
            injectedItems: [
              InjectionInjectedItem(
                key: "my-unique-injected-item-key",
                source: InjectedItemSearchSource(
                  search: InjectedItemSearch(
                    index: "my-index",
                  ),
                ),
                position: 0,
                length: 3,
              ),
            ],
            deduplication: Deduplication(
              positioning: DedupPositioning.fromJson("highestInjected"),
            ),
          ),
        ),
      ),
    ),
  );

  // print the response
  print(response);
  ```

  ```go Go theme={"system"}
  // Initialize the client
  client, err := composition.NewClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
  if err != nil {
    // The client can fail to initialize if you pass an invalid parameter.
    panic(err)
  }

  // Call the API
  response, err := client.PutCompositionRule(client.NewApiPutCompositionRuleRequest(
    "compositionID", "rule-with-deduplication",
    composition.NewEmptyCompositionRule().SetObjectID("rule-with-deduplication").SetDescription("my description").SetEnabled(true).SetConditions(
      []composition.Condition{
        *composition.NewEmptyCondition().SetAnchoring(composition.Anchoring("contains")).SetPattern("harry"),
      }).
      SetConsequence(
        composition.NewEmptyCompositionRuleConsequence().SetBehavior(composition.CompositionInjectionBehaviorAsCompositionBehavior(
          composition.NewEmptyCompositionInjectionBehavior().SetInjection(
            composition.NewEmptyInjection().SetMain(
              composition.NewEmptyInjectionMain().SetSource(composition.InjectionMainSearchSourceAsInjectionMainSource(
                composition.NewEmptyInjectionMainSearchSource().SetSearch(
                  composition.NewEmptyMainSearch().SetIndex("my-index"))))).SetInjectedItems(
              []composition.InjectionInjectedItem{
                *composition.NewEmptyInjectionInjectedItem().SetKey("my-unique-injected-item-key").SetSource(composition.InjectedItemSearchSourceAsInjectedItemSource(
                  composition.NewEmptyInjectedItemSearchSource().SetSearch(
                    composition.NewEmptyInjectedItemSearch().SetIndex("my-index")))).SetPosition(0).SetLength(3),
              }).
              SetDeduplication(
                composition.NewEmptyDeduplication().SetPositioning(composition.DedupPositioning("highestInjected")))))))))
  if err != nil {
    // handle the eventual error
    panic(err)
  }


  // print the response
  print(response)
  ```

  ```java Java theme={"system"}
  // Initialize the client
  CompositionClient client = new CompositionClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");

  // Call the API
  TaskIDResponse response = client.putCompositionRule(
    "compositionID",
    "rule-with-deduplication",
    new CompositionRule()
      .setObjectID("rule-with-deduplication")
      .setDescription("my description")
      .setEnabled(true)
      .setConditions(Arrays.asList(new Condition().setAnchoring(Anchoring.CONTAINS).setPattern("harry")))
      .setConsequence(
        new CompositionRuleConsequence().setBehavior(
          new CompositionInjectionBehavior().setInjection(
            new Injection()
              .setMain(new InjectionMain().setSource(new InjectionMainSearchSource().setSearch(new MainSearch().setIndex("my-index"))))
              .setInjectedItems(
                Arrays.asList(
                  new InjectionInjectedItem()
                    .setKey("my-unique-injected-item-key")
                    .setSource(new InjectedItemSearchSource().setSearch(new InjectedItemSearch().setIndex("my-index")))
                    .setPosition(0)
                    .setLength(3)
                )
              )
              .setDeduplication(new Deduplication().setPositioning(DedupPositioning.HIGHEST_INJECTED))
          )
        )
      )
  );

  // print the response
  System.out.println(response);
  ```

  ```js JavaScript theme={"system"}
  // Initialize the client
  const client = compositionClient('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

  // Call the API
  const response = await client.putCompositionRule({
    compositionID: 'compositionID',
    objectID: 'rule-with-deduplication',
    compositionRule: {
      objectID: 'rule-with-deduplication',
      description: 'my description',
      enabled: true,
      conditions: [{ anchoring: 'contains', pattern: 'harry' }],
      consequence: {
        behavior: {
          injection: {
            main: { source: { search: { index: 'my-index' } } },
            injectedItems: [
              { key: 'my-unique-injected-item-key', source: { search: { index: 'my-index' } }, position: 0, length: 3 },
            ],
            deduplication: { positioning: 'highestInjected' },
          },
        },
      },
    },
  });


  // print the response
  console.log(response);
  ```

  ```kotlin Kotlin theme={"system"}
  // Initialize the client
  val client = CompositionClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

  // Call the API
  var response =
    client.putCompositionRule(
      compositionID = "compositionID",
      objectID = "rule-with-deduplication",
      compositionRule =
        CompositionRule(
          objectID = "rule-with-deduplication",
          description = "my description",
          enabled = true,
          conditions =
            listOf(
              Condition(
                anchoring = Anchoring.entries.first { it.value == "contains" },
                pattern = "harry",
              )
            ),
          consequence =
            CompositionRuleConsequence(
              behavior =
                CompositionInjectionBehavior(
                  injection =
                    Injection(
                      main =
                        InjectionMain(
                          source =
                            InjectionMainSearchSource(search = MainSearch(index = "my-index"))
                        ),
                      injectedItems =
                        listOf(
                          InjectionInjectedItem(
                            key = "my-unique-injected-item-key",
                            source =
                              InjectedItemSearchSource(
                                search = InjectedItemSearch(index = "my-index")
                              ),
                            position = 0,
                            length = 3,
                          )
                        ),
                      deduplication =
                        Deduplication(
                          positioning =
                            DedupPositioning.entries.first { it.value == "highestInjected" }
                        ),
                    )
                )
            ),
        ),
    )


  // print the response
  println(response)
  ```

  ```php PHP theme={"system"}
  // Initialize the client
  $client = CompositionClient::create('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

  // Call the API
  $response = $client->putCompositionRule(
      'compositionID',
      'rule-with-deduplication',
      ['objectID' => 'rule-with-deduplication',
          'description' => 'my description',
          'enabled' => true,
          'conditions' => [
              ['anchoring' => 'contains',
                  'pattern' => 'harry',
              ],
          ],
          'consequence' => ['behavior' => ['injection' => ['main' => ['source' => ['search' => ['index' => 'my-index',
          ],
          ],
          ],
              'injectedItems' => [
                  ['key' => 'my-unique-injected-item-key',
                      'source' => ['search' => ['index' => 'my-index',
                      ],
                      ],
                      'position' => 0,
                      'length' => 3,
                  ],
              ],
              'deduplication' => ['positioning' => 'highestInjected',
              ],
          ],
          ],
          ],
      ],
  );


  // print the response
  var_dump($response);
  ```

  ```python Python theme={"system"}
  # Initialize the client
  # In an asynchronous context, you can use CompositionClient instead, which exposes the exact same methods.
  client = CompositionClientSync("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

  # Call the API
  response = client.put_composition_rule(
      composition_id="compositionID",
      object_id="rule-with-deduplication",
      composition_rule={
          "objectID": "rule-with-deduplication",
          "description": "my description",
          "enabled": True,
          "conditions": [
              {
                  "anchoring": "contains",
                  "pattern": "harry",
              },
          ],
          "consequence": {
              "behavior": {
                  "injection": {
                      "main": {
                          "source": {
                              "search": {
                                  "index": "my-index",
                              },
                          },
                      },
                      "injectedItems": [
                          {
                              "key": "my-unique-injected-item-key",
                              "source": {
                                  "search": {
                                      "index": "my-index",
                                  },
                              },
                              "position": 0,
                              "length": 3,
                          },
                      ],
                      "deduplication": {
                          "positioning": "highestInjected",
                      },
                  },
              },
          },
      },
  )


  # print the response
  print(response)
  ```

  ```ruby Ruby theme={"system"}
  # Initialize the client
  client = Algolia::CompositionClient.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

  # Call the API
  response = client.put_composition_rule(
    "compositionID",
    "rule-with-deduplication",
    Algolia::Composition::CompositionRule.new(
      algolia_object_id: "rule-with-deduplication",
      description: "my description",
      enabled: true,
      conditions: [Algolia::Composition::Condition.new(anchoring: "contains", pattern: "harry")],
      consequence: Algolia::Composition::CompositionRuleConsequence.new(
        behavior: Algolia::Composition::CompositionInjectionBehavior.new(
          injection: Algolia::Composition::Injection.new(
            main: Algolia::Composition::InjectionMain.new(
              source: Algolia::Composition::InjectionMainSearchSource.new(
                search: Algolia::Composition::MainSearch.new(index: "my-index")
              )
            ),
            injected_items: [
              Algolia::Composition::InjectionInjectedItem.new(
                key: "my-unique-injected-item-key",
                source: Algolia::Composition::InjectedItemSearchSource.new(
                  search: Algolia::Composition::InjectedItemSearch.new(index: "my-index")
                ),
                position: 0,
                length: 3
              )
            ],
            deduplication: Algolia::Composition::Deduplication.new(positioning: "highestInjected")
          )
        )
      )
    )
  )


  # print the response
  puts(response)
  ```

  ```scala Scala theme={"system"}
  // Initialize the client
  val client = CompositionClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

  // Call the API
  val response = Await.result(
    client.putCompositionRule(
      compositionID = "compositionID",
      objectID = "rule-with-deduplication",
      compositionRule = CompositionRule(
        objectID = "rule-with-deduplication",
        description = Some("my description"),
        enabled = Some(true),
        conditions = Some(
          Seq(
            Condition(
              anchoring = Some(Anchoring.withName("contains")),
              pattern = Some("harry")
            )
          )
        ),
        consequence = CompositionRuleConsequence(
          behavior = CompositionInjectionBehavior(
            injection = Injection(
              main = InjectionMain(
                source = Some(
                  InjectionMainSearchSource(
                    search = MainSearch(
                      index = "my-index"
                    )
                  )
                )
              ),
              injectedItems = Some(
                Seq(
                  InjectionInjectedItem(
                    key = "my-unique-injected-item-key",
                    source = InjectedItemSearchSource(
                      search = InjectedItemSearch(
                        index = "my-index"
                      )
                    ),
                    position = 0,
                    length = 3
                  )
                )
              ),
              deduplication = Some(
                Deduplication(
                  positioning = DedupPositioning.withName("highestInjected")
                )
              )
            )
          )
        )
      )
    ),
    Duration(100, "sec")
  )

  // print the response
  println(response)
  ```

  ```swift Swift theme={"system"}
  // Initialize the client
  let client = try CompositionClient(appID: "ALGOLIA_APPLICATION_ID", apiKey: "ALGOLIA_API_KEY")

  // Call the API
  let response = try await client.putCompositionRule(
      compositionID: "compositionID",
      objectID: "rule-with-deduplication",
      compositionRule: CompositionRule(
          objectID: "rule-with-deduplication",
          conditions: [CompositionCondition(pattern: "harry", anchoring: CompositionAnchoring.contains)],
          consequence: CompositionRuleConsequence(behavior: CompositionBehavior
              .compositionInjectionBehavior(CompositionInjectionBehavior(injection: Injection(
                  main: InjectionMain(source: InjectionMainSource
                      .injectionMainSearchSource(
                          InjectionMainSearchSource(search: MainSearch(index: "my-index"))
                      )),
                  injectedItems: [InjectionInjectedItem(
                      key: "my-unique-injected-item-key",
                      source: InjectedItemSource
                          .injectedItemSearchSource(
                              InjectedItemSearchSource(search: InjectedItemSearch(index: "my-index"))
                          ),
                      position: 0,
                      length: 3
                  )],
                  deduplication: Deduplication(positioning: DedupPositioning.highestInjected)
              )))),
          description: "my description",
          enabled: true
      )
  )

  // print the response
  print(response)
  ```
</CodeGroup>

<Card icon="folder-code" horizontal="true" title="See the full API reference" arrow="true" href="/doc/rest-api/composition/put-composition-rule">
  For more details about input parameters
  and response fields.
</Card>