API Reference / API Methods / Personalization / Add strategy

Feb. 26, 2019

Add Strategy

Required API Key: any key with the editSettings ACL

Method signature

$client->setPersonalizationStrategy(array strategy)

client.set_personalization_strategy(Map strategy)

client.setPersonalizationStrategy(object strategy, callback)

client.set_personalization_strategy(dict strategy)

This method is not available in mobile API clients.

Personalization needs to be configured via
the Algolia Dashboard or with one of our backend API clients.

suspend fun ClientSearch.setPersonalizationStrategy(
    strategy: PersonalizationStrategy,
    requestOptions: RequestOptions? = null
): Revision

This method is not available in mobile API clients.

Personalization needs to be configured via
the Algolia Dashboard or with one of our backend API clients.

client.SetPersonalizationStrategy(
  SetStrategyRequest strategy
)

client.setPersonalizationStrategy(SetStrategyRequest strategy)

client.SetPersonalizationStrategy(Strategy)

set personalizationStrategy Strategy(...)

See code examples

About this method

Set a personalization strategy for your application

Examples

Copy

$client->setPersonalizationStrategy([
    'eventsScoring' => [
        'Add to cart' => ['score' => 50, 'type' => 'conversion'],
        'Purchase' => ['score' => 100, 'type' => 'conversion']
    ],
    'facetsScoring' => [
        'brand' => ['score' => 100],
        'categories' => ['score' => 10]
    ]
]);

client.set_personalization_strategy({
    eventsScoring: {
        'Add to cart': {score: 50, type: 'conversion'},
        Purchase: {score: 100, type: 'conversion'}
    },
    facetsScoring: {
        brand: {score: 100},
        categories: {score: 10}
    }
})

client.setPersonalizationStrategy(
  {
    eventsScoring: {
      'Add to cart': { score: 50, type: 'conversion' },
      Purchase: { score: 100, type: 'conversion' }
    },
    facetsScoring: {
      brand: { score: 100 },
      categories: { score: 10 }
    }
  },
  err => {
    /* ... */
  }
);

client.set_personalization_strategy({
    'eventsScoring': {
        'Add to cart': {'score': 50, 'type': 'conversion'},
        'Purchase': {'score': 100, 'type': 'conversion'}
    },
    'facetsScoring': {
        'brand': {'score': 100},
        'categories': {'score': 10}
    }
})

var strategyToSave = new SetStrategyRequest
{
    FacetsScoring = new Dictionary<string, FacetScoring>
    {
        {"brand", new FacetScoring { Score = 100}},
        {"categories", new FacetScoring { Score = 10}}
    },
    EventsScoring = new Dictionary<string, EventScoring>
    {
        {"Add to cart", new EventScoring { Score = 50, Type = "conversion" }},
        {"Purchase", new EventScoring { Score = 100, Type = "conversion" }}
    }
};

var response = client.SetPersonalizationStrategy(strategyToSave);

// Asynchronous
var response = await client.SetPersonalizationStrategyAsync(strategyToSave);

HashMap<String, EventScoring> eventsScoring = new HashMap<>();

eventsScoring.put(
  "Add to cart",
   new EventScoring().setScore(50).setType("conversion"));

eventsScoring.put(
  "Purchase",
   new EventScoring().setScore(100).setType("conversion"));

HashMap<String, FacetScoring> facetsScoring = new HashMap<>();

facetsScoring.put("brand", new FacetScoring().setScore(100));
facetsScoring.put("categories", new FacetScoring().setScore(10));

SetStrategyRequest request = new SetStrategyRequest()
        .setEventsScoring(eventsScoring)
        .setFacetsScoring(facetsScoring);

SetStrategyResponse result = client.setPersonalizationStrategy(request);

strategy := search.Strategy{
  EventsScoring: map[string]search.EventsScoring{
    "Add to cart": {50, "conversion"},
    "Purchase":    {99, "conversion"},
  },
  FacetsScoring: map[string]search.FacetsScoring{
    "brand":      {100},
    "categories": {100},
  },
}

res, err := client.SetPersonalizationStrategy(strategy)

val strategy = Strategy(
  eventsScoring = Some(Map(
    "Add to cart" -> ScoreType(50, "conversion"),
    "Purchase" -> ScoreType(100, "conversion"),
  )),
  facetsScoring = Some(Map(
    "brand" -> Score(100),
    "categories" -> Score(10),
  ))
)

client.execute {
  set personalizationStrategy strategy
}

val strategy = PersonalizationStrategy(
    facetsScoring = mapOf(
        Attribute("brand") to FacetScoring(100),
        Attribute("categories") to FacetScoring(10)
    ),
    eventsScoring = mapOf(
        EventName("Add to cart") to EventScoring(EventType.Conversion, 50),
        EventName("Purchase") to EventScoring(EventType.Conversion, 100)
    )
)

client.setPersonalizationStrategy(strategy)

Parameters


            strategy

type: object

Required

A strategy object.

{
  "eventScoring": eventsScoring,
  "facetsScoring": facetsScoring
}

strategy


            eventsScoring

type: object

Required

Associate a score to an event

Copy
{
  "${eventName}": {
    "score": int // mandatory
    "type": string // mandatory
  }
}


            facetsScoring

type: object

Required

Associate a score to a facet.

Copy
  {
    "${facetName}": {
      "score": int // mandatory
    }
  }

Response

No response

Building Search UI

Building Search UI

Building Search UI

Building Search UI

Building Search UI

Building Search UI

PHP

Ruby

JavaScript

Python

iOS

Kotlin

Android

.NET

Java

Golang

Scala

InstantSearch.js

React InstantSearch

Vue InstantSearch

Angular InstantSearch

iOS InstantSearch

Android InstantSearch

Index settings and search parameters

A full reference of API Endpoints

Rails

Symfony

Django

Laravel

Magento 1

Magento 2

WordPress

Shopify

Add Strategy

About this method

Examples

Parameters

strategy

Response

Did you find this page helpful?

On this page