> ## 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 and insert (upsert) a composition
> Update and insert a composition in the current Algolia application.
**Required ACL:** `editSettings`
## Usage
```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.PutCompositionAsync(
"my-compo",
new Composition
{
ObjectID = "my-compo",
Name = "my composition",
Behavior = new CompositionBehavior(
new CompositionMultifeedBehavior
{
Multifeed = new Multifeed
{
Feeds = new Dictionary
{
{
"products",
new FeedInjection
{
Injection = new Injection
{
Main = new InjectionMain
{
Source = new InjectionMainSource(
new InjectionMainSearchSource
{
Search = new MainSearch
{
Index = "products",
Params = new MainInjectionQueryParameters { HitsPerPage = 12 },
},
}
),
},
InjectedItems = new List
{
new InjectionInjectedItem
{
Key = "featured-products",
Source = new InjectedItemSource(
new InjectedItemSearchSource
{
Search = new InjectedItemSearch
{
Index = "products",
Params = new BaseInjectionQueryParameters
{
Filters = "featured:true",
},
},
}
),
Position = 0,
Length = 2,
},
},
},
}
},
{
"articles",
new FeedInjection
{
Injection = new Injection
{
Main = new InjectionMain
{
Source = new InjectionMainSource(
new InjectionMainSearchSource
{
Search = new MainSearch
{
Index = "articles",
Params = new MainInjectionQueryParameters
{
HitsPerPage = 5,
AttributesToRetrieve = new List
{
"title",
"excerpt",
"publishedAt",
},
},
},
}
),
},
InjectedItems = new List
{
new InjectionInjectedItem
{
Key = "editorial-picks",
Source = new InjectedItemSource(
new InjectedItemSearchSource
{
Search = new InjectedItemSearch
{
Index = "articles",
Params = new BaseInjectionQueryParameters
{
Filters = "editorial_pick:true",
},
},
}
),
Position = 0,
Length = 1,
},
},
},
}
},
{
"videos",
new FeedInjection
{
Injection = new Injection
{
Main = new InjectionMain
{
Source = new InjectionMainSource(
new InjectionMainSearchSource
{
Search = new MainSearch
{
Index = "videos",
Params = new MainInjectionQueryParameters
{
HitsPerPage = 3,
AttributesToRetrieve = new List
{
"title",
"thumbnail",
"duration",
},
},
},
}
),
},
},
}
},
},
FeedsOrder = new List { "products", "articles", "videos" },
},
}
),
}
);
// 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.putComposition(
compositionID: "my-compo",
composition: Composition(
objectID: "my-compo",
name: "my composition",
behavior: CompositionMultifeedBehavior(
multifeed: Multifeed(
feeds: {
'products': FeedInjection(
injection: Injection(
main: InjectionMain(
source: InjectionMainSearchSource(
search: MainSearch(
index: "products",
params: MainInjectionQueryParameters(
hitsPerPage: 12,
),
),
),
),
injectedItems: [
InjectionInjectedItem(
key: "featured-products",
source: InjectedItemSearchSource(
search: InjectedItemSearch(
index: "products",
params: BaseInjectionQueryParameters(
filters: "featured:true",
),
),
),
position: 0,
length: 2,
),
],
),
),
'articles': FeedInjection(
injection: Injection(
main: InjectionMain(
source: InjectionMainSearchSource(
search: MainSearch(
index: "articles",
params: MainInjectionQueryParameters(
hitsPerPage: 5,
attributesToRetrieve: [
"title",
"excerpt",
"publishedAt",
],
),
),
),
),
injectedItems: [
InjectionInjectedItem(
key: "editorial-picks",
source: InjectedItemSearchSource(
search: InjectedItemSearch(
index: "articles",
params: BaseInjectionQueryParameters(
filters: "editorial_pick:true",
),
),
),
position: 0,
length: 1,
),
],
),
),
'videos': FeedInjection(
injection: Injection(
main: InjectionMain(
source: InjectionMainSearchSource(
search: MainSearch(
index: "videos",
params: MainInjectionQueryParameters(
hitsPerPage: 3,
attributesToRetrieve: [
"title",
"thumbnail",
"duration",
],
),
),
),
),
),
),
},
feedsOrder: [
"products",
"articles",
"videos",
],
),
),
),
);
// 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.PutComposition(client.NewApiPutCompositionRequest(
"my-compo",
composition.NewEmptyComposition().
SetObjectID("my-compo").
SetName("my composition").
SetBehavior(composition.CompositionMultifeedBehaviorAsCompositionBehavior(
composition.NewEmptyCompositionMultifeedBehavior().SetMultifeed(
composition.NewEmptyMultifeed().
SetFeeds(map[string]composition.FeedInjection{"products": *composition.NewEmptyFeedInjection().SetInjection(
composition.NewEmptyInjection().SetMain(
composition.NewEmptyInjectionMain().SetSource(composition.InjectionMainSearchSourceAsInjectionMainSource(
composition.NewEmptyInjectionMainSearchSource().SetSearch(
composition.NewEmptyMainSearch().SetIndex("products").SetParams(
composition.NewEmptyMainInjectionQueryParameters().SetHitsPerPage(12)))))).SetInjectedItems(
[]composition.InjectionInjectedItem{*composition.NewEmptyInjectionInjectedItem().SetKey("featured-products").SetSource(composition.InjectedItemSearchSourceAsInjectedItemSource(
composition.NewEmptyInjectedItemSearchSource().SetSearch(
composition.NewEmptyInjectedItemSearch().SetIndex("products").SetParams(
composition.NewEmptyBaseInjectionQueryParameters().SetFilters("featured:true"))))).SetPosition(0).SetLength(2)})), "articles": *composition.NewEmptyFeedInjection().SetInjection(
composition.NewEmptyInjection().SetMain(
composition.NewEmptyInjectionMain().SetSource(composition.InjectionMainSearchSourceAsInjectionMainSource(
composition.NewEmptyInjectionMainSearchSource().SetSearch(
composition.NewEmptyMainSearch().SetIndex("articles").SetParams(
composition.NewEmptyMainInjectionQueryParameters().SetHitsPerPage(5).SetAttributesToRetrieve(
[]string{"title", "excerpt", "publishedAt"})))))).SetInjectedItems(
[]composition.InjectionInjectedItem{*composition.NewEmptyInjectionInjectedItem().SetKey("editorial-picks").SetSource(composition.InjectedItemSearchSourceAsInjectedItemSource(
composition.NewEmptyInjectedItemSearchSource().SetSearch(
composition.NewEmptyInjectedItemSearch().SetIndex("articles").SetParams(
composition.NewEmptyBaseInjectionQueryParameters().SetFilters("editorial_pick:true"))))).SetPosition(0).SetLength(1)})), "videos": *composition.NewEmptyFeedInjection().SetInjection(
composition.NewEmptyInjection().SetMain(
composition.NewEmptyInjectionMain().SetSource(composition.InjectionMainSearchSourceAsInjectionMainSource(
composition.NewEmptyInjectionMainSearchSource().SetSearch(
composition.NewEmptyMainSearch().SetIndex("videos").SetParams(
composition.NewEmptyMainInjectionQueryParameters().SetHitsPerPage(3).SetAttributesToRetrieve(
[]string{"title", "thumbnail", "duration"})))))))}).
SetFeedsOrder(
[]string{"products", "articles", "videos"}),
),
)),
))
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.putComposition(
"my-compo",
new Composition()
.setObjectID("my-compo")
.setName("my composition")
.setBehavior(
new CompositionMultifeedBehavior().setMultifeed(
new Multifeed()
.setFeeds(
new HashMap() {
{
put(
"products",
new FeedInjection().setInjection(
new Injection()
.setMain(
new InjectionMain().setSource(
new InjectionMainSearchSource().setSearch(
new MainSearch().setIndex("products").setParams(new MainInjectionQueryParameters().setHitsPerPage(12))
)
)
)
.setInjectedItems(
Arrays.asList(
new InjectionInjectedItem()
.setKey("featured-products")
.setSource(
new InjectedItemSearchSource().setSearch(
new InjectedItemSearch()
.setIndex("products")
.setParams(new BaseInjectionQueryParameters().setFilters("featured:true"))
)
)
.setPosition(0)
.setLength(2)
)
)
)
);
put(
"articles",
new FeedInjection().setInjection(
new Injection()
.setMain(
new InjectionMain().setSource(
new InjectionMainSearchSource().setSearch(
new MainSearch()
.setIndex("articles")
.setParams(
new MainInjectionQueryParameters()
.setHitsPerPage(5)
.setAttributesToRetrieve(Arrays.asList("title", "excerpt", "publishedAt"))
)
)
)
)
.setInjectedItems(
Arrays.asList(
new InjectionInjectedItem()
.setKey("editorial-picks")
.setSource(
new InjectedItemSearchSource().setSearch(
new InjectedItemSearch()
.setIndex("articles")
.setParams(new BaseInjectionQueryParameters().setFilters("editorial_pick:true"))
)
)
.setPosition(0)
.setLength(1)
)
)
)
);
put(
"videos",
new FeedInjection().setInjection(
new Injection().setMain(
new InjectionMain().setSource(
new InjectionMainSearchSource().setSearch(
new MainSearch()
.setIndex("videos")
.setParams(
new MainInjectionQueryParameters()
.setHitsPerPage(3)
.setAttributesToRetrieve(Arrays.asList("title", "thumbnail", "duration"))
)
)
)
)
)
);
}
}
)
.setFeedsOrder(Arrays.asList("products", "articles", "videos"))
)
)
);
// 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.putComposition({
compositionID: 'my-compo',
composition: {
objectID: 'my-compo',
name: 'my composition',
behavior: {
multifeed: {
feeds: {
products: {
injection: {
main: { source: { search: { index: 'products', params: { hitsPerPage: 12 } } } },
injectedItems: [
{
key: 'featured-products',
source: { search: { index: 'products', params: { filters: 'featured:true' } } },
position: 0,
length: 2,
},
],
},
},
articles: {
injection: {
main: {
source: {
search: {
index: 'articles',
params: { hitsPerPage: 5, attributesToRetrieve: ['title', 'excerpt', 'publishedAt'] },
},
},
},
injectedItems: [
{
key: 'editorial-picks',
source: { search: { index: 'articles', params: { filters: 'editorial_pick:true' } } },
position: 0,
length: 1,
},
],
},
},
videos: {
injection: {
main: {
source: {
search: {
index: 'videos',
params: { hitsPerPage: 3, attributesToRetrieve: ['title', 'thumbnail', 'duration'] },
},
},
},
},
},
},
feedsOrder: ['products', 'articles', 'videos'],
},
},
},
});
// 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.putComposition(
compositionID = "my-compo",
composition =
Composition(
objectID = "my-compo",
name = "my composition",
behavior =
CompositionMultifeedBehavior(
multifeed =
Multifeed(
feeds =
mapOf(
"products" to
FeedInjection(
injection =
Injection(
main =
InjectionMain(
source =
InjectionMainSearchSource(
search =
MainSearch(
index = "products",
params = MainInjectionQueryParameters(hitsPerPage = 12),
)
)
),
injectedItems =
listOf(
InjectionInjectedItem(
key = "featured-products",
source =
InjectedItemSearchSource(
search =
InjectedItemSearch(
index = "products",
params =
BaseInjectionQueryParameters(
filters = "featured:true"
),
)
),
position = 0,
length = 2,
)
),
)
),
"articles" to
FeedInjection(
injection =
Injection(
main =
InjectionMain(
source =
InjectionMainSearchSource(
search =
MainSearch(
index = "articles",
params =
MainInjectionQueryParameters(
hitsPerPage = 5,
attributesToRetrieve =
listOf("title", "excerpt", "publishedAt"),
),
)
)
),
injectedItems =
listOf(
InjectionInjectedItem(
key = "editorial-picks",
source =
InjectedItemSearchSource(
search =
InjectedItemSearch(
index = "articles",
params =
BaseInjectionQueryParameters(
filters = "editorial_pick:true"
),
)
),
position = 0,
length = 1,
)
),
)
),
"videos" to
FeedInjection(
injection =
Injection(
main =
InjectionMain(
source =
InjectionMainSearchSource(
search =
MainSearch(
index = "videos",
params =
MainInjectionQueryParameters(
hitsPerPage = 3,
attributesToRetrieve =
listOf("title", "thumbnail", "duration"),
),
)
)
)
)
),
),
feedsOrder = listOf("products", "articles", "videos"),
)
),
),
)
// 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->putComposition(
'my-compo',
['objectID' => 'my-compo',
'name' => 'my composition',
'behavior' => ['multifeed' => ['feeds' => ['products' => ['injection' => ['main' => ['source' => ['search' => ['index' => 'products',
'params' => ['hitsPerPage' => 12,
],
],
],
],
'injectedItems' => [
['key' => 'featured-products',
'source' => ['search' => ['index' => 'products',
'params' => ['filters' => 'featured:true',
],
],
],
'position' => 0,
'length' => 2,
],
],
],
],
'articles' => ['injection' => ['main' => ['source' => ['search' => ['index' => 'articles',
'params' => ['hitsPerPage' => 5,
'attributesToRetrieve' => [
'title',
'excerpt',
'publishedAt',
],
],
],
],
],
'injectedItems' => [
['key' => 'editorial-picks',
'source' => ['search' => ['index' => 'articles',
'params' => ['filters' => 'editorial_pick:true',
],
],
],
'position' => 0,
'length' => 1,
],
],
],
],
'videos' => ['injection' => ['main' => ['source' => ['search' => ['index' => 'videos',
'params' => ['hitsPerPage' => 3,
'attributesToRetrieve' => [
'title',
'thumbnail',
'duration',
],
],
],
],
],
],
],
],
'feedsOrder' => [
'products',
'articles',
'videos',
],
],
],
],
);
// 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(
composition_id="my-compo",
composition={
"objectID": "my-compo",
"name": "my composition",
"behavior": {
"multifeed": {
"feeds": {
"products": {
"injection": {
"main": {
"source": {
"search": {
"index": "products",
"params": {
"hitsPerPage": 12,
},
},
},
},
"injectedItems": [
{
"key": "featured-products",
"source": {
"search": {
"index": "products",
"params": {
"filters": "featured:true",
},
},
},
"position": 0,
"length": 2,
},
],
},
},
"articles": {
"injection": {
"main": {
"source": {
"search": {
"index": "articles",
"params": {
"hitsPerPage": 5,
"attributesToRetrieve": [
"title",
"excerpt",
"publishedAt",
],
},
},
},
},
"injectedItems": [
{
"key": "editorial-picks",
"source": {
"search": {
"index": "articles",
"params": {
"filters": "editorial_pick:true",
},
},
},
"position": 0,
"length": 1,
},
],
},
},
"videos": {
"injection": {
"main": {
"source": {
"search": {
"index": "videos",
"params": {
"hitsPerPage": 3,
"attributesToRetrieve": [
"title",
"thumbnail",
"duration",
],
},
},
},
},
},
},
},
"feedsOrder": [
"products",
"articles",
"videos",
],
},
},
},
)
# 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(
"my-compo",
Algolia::Composition::Composition.new(
algolia_object_id: "my-compo",
name: "my composition",
behavior: Algolia::Composition::CompositionMultifeedBehavior.new(
multifeed: Algolia::Composition::Multifeed.new(
feeds: {
products: Algolia::Composition::FeedInjection.new(
injection: Algolia::Composition::Injection.new(
main: Algolia::Composition::InjectionMain.new(
source: Algolia::Composition::InjectionMainSearchSource.new(
search: Algolia::Composition::MainSearch.new(
index: "products",
params: Algolia::Composition::MainInjectionQueryParameters.new(hits_per_page: 12)
)
)
),
injected_items: [
Algolia::Composition::InjectionInjectedItem.new(
key: "featured-products",
source: Algolia::Composition::InjectedItemSearchSource.new(
search: Algolia::Composition::InjectedItemSearch.new(
index: "products",
params: Algolia::Composition::BaseInjectionQueryParameters.new(filters: "featured:true")
)
),
position: 0,
length: 2
)
]
)
),
articles: Algolia::Composition::FeedInjection.new(
injection: Algolia::Composition::Injection.new(
main: Algolia::Composition::InjectionMain.new(
source: Algolia::Composition::InjectionMainSearchSource.new(
search: Algolia::Composition::MainSearch.new(
index: "articles",
params: Algolia::Composition::MainInjectionQueryParameters.new(
hits_per_page: 5,
attributes_to_retrieve: ["title", "excerpt", "publishedAt"]
)
)
)
),
injected_items: [
Algolia::Composition::InjectionInjectedItem.new(
key: "editorial-picks",
source: Algolia::Composition::InjectedItemSearchSource.new(
search: Algolia::Composition::InjectedItemSearch.new(
index: "articles",
params: Algolia::Composition::BaseInjectionQueryParameters.new(filters: "editorial_pick:true")
)
),
position: 0,
length: 1
)
]
)
),
videos: Algolia::Composition::FeedInjection.new(
injection: Algolia::Composition::Injection.new(
main: Algolia::Composition::InjectionMain.new(
source: Algolia::Composition::InjectionMainSearchSource.new(
search: Algolia::Composition::MainSearch.new(
index: "videos",
params: Algolia::Composition::MainInjectionQueryParameters.new(
hits_per_page: 3,
attributes_to_retrieve: ["title", "thumbnail", "duration"]
)
)
)
)
)
)
},
feeds_order: ["products", "articles", "videos"]
)
)
)
)
# 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.putComposition(
compositionID = "my-compo",
composition = Composition(
objectID = "my-compo",
name = "my composition",
behavior = CompositionMultifeedBehavior(
multifeed = Multifeed(
feeds = Map(
"products" -> FeedInjection(
injection = Injection(
main = InjectionMain(
source = Some(
InjectionMainSearchSource(
search = MainSearch(
index = "products",
params = Some(
MainInjectionQueryParameters(
hitsPerPage = Some(12)
)
)
)
)
)
),
injectedItems = Some(
Seq(
InjectionInjectedItem(
key = "featured-products",
source = InjectedItemSearchSource(
search = InjectedItemSearch(
index = "products",
params = Some(
BaseInjectionQueryParameters(
filters = Some("featured:true")
)
)
)
),
position = 0,
length = 2
)
)
)
)
),
"articles" -> FeedInjection(
injection = Injection(
main = InjectionMain(
source = Some(
InjectionMainSearchSource(
search = MainSearch(
index = "articles",
params = Some(
MainInjectionQueryParameters(
hitsPerPage = Some(5),
attributesToRetrieve = Some(Seq("title", "excerpt", "publishedAt"))
)
)
)
)
)
),
injectedItems = Some(
Seq(
InjectionInjectedItem(
key = "editorial-picks",
source = InjectedItemSearchSource(
search = InjectedItemSearch(
index = "articles",
params = Some(
BaseInjectionQueryParameters(
filters = Some("editorial_pick:true")
)
)
)
),
position = 0,
length = 1
)
)
)
)
),
"videos" -> FeedInjection(
injection = Injection(
main = InjectionMain(
source = Some(
InjectionMainSearchSource(
search = MainSearch(
index = "videos",
params = Some(
MainInjectionQueryParameters(
hitsPerPage = Some(3),
attributesToRetrieve = Some(Seq("title", "thumbnail", "duration"))
)
)
)
)
)
)
)
)
),
feedsOrder = Some(Seq("products", "articles", "videos"))
)
)
)
),
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.putComposition(
compositionID: "my-compo",
composition: Composition(
objectID: "my-compo",
name: "my composition",
behavior: CompositionBehavior
.compositionMultifeedBehavior(CompositionMultifeedBehavior(multifeed: Multifeed(
feeds: [
"products": FeedInjection(injection: Injection(
main: InjectionMain(source: InjectionMainSource
.injectionMainSearchSource(InjectionMainSearchSource(search: MainSearch(
index: "products",
params: MainInjectionQueryParameters(hitsPerPage: 12)
)))),
injectedItems: [InjectionInjectedItem(
key: "featured-products",
source: InjectedItemSource
.injectedItemSearchSource(InjectedItemSearchSource(search: InjectedItemSearch(
index: "products",
params: BaseInjectionQueryParameters(filters: "featured:true")
))),
position: 0,
length: 2
)]
)),
"articles": FeedInjection(injection: Injection(
main: InjectionMain(source: InjectionMainSource
.injectionMainSearchSource(InjectionMainSearchSource(search: MainSearch(
index: "articles",
params: MainInjectionQueryParameters(
attributesToRetrieve: ["title", "excerpt", "publishedAt"],
hitsPerPage: 5
)
)))),
injectedItems: [InjectionInjectedItem(
key: "editorial-picks",
source: InjectedItemSource
.injectedItemSearchSource(InjectedItemSearchSource(search: InjectedItemSearch(
index: "articles",
params: BaseInjectionQueryParameters(filters: "editorial_pick:true")
))),
position: 0,
length: 1
)]
)),
"videos": FeedInjection(injection: Injection(main: InjectionMain(source: InjectionMainSource
.injectionMainSearchSource(InjectionMainSearchSource(search: MainSearch(
index: "videos",
params: MainInjectionQueryParameters(
attributesToRetrieve: ["title", "thumbnail", "duration"],
hitsPerPage: 3
)
)))))),
],
feedsOrder: ["products", "articles", "videos"]
)))
)
)
// print the response
print(response)
```
For more details about input parameters
and response fields.