Getting Started

import com.recombee.apiclientkotlin.RecombeeClient
import com.recombee.apiclientkotlin.util.Region
import com.recombee.apiclientkotlin.requests.*
import com.recombee.apiclientkotlin.exceptions.ApiException

val client = RecombeeClient(
    databaseId = "your-db-id",
    publicToken = "your-public-token",
    region = Region.UsWest
)

val request = AddDetailView(userId = "2c169e", itemId = "xyz")

client.send(request,
    { response ->
        ...
    },
    { exception ->
        ...
    }
)
// Alternatively, you can use sendAsync for coroutines instead of callbacks

let client = RecombeeClient(
    databaseId: "your-db-id",
    publicToken: "your-public-token",
    region: .usWest
)

let request = AddDetailView(userId: "2c169e", itemId: "xyz")

do {
    let response = try await client.send(request)
    // Handle the successful response
    print("Success: \(response)")
} catch {
    // Handle the error (e.g. ClientError or any other error)
    print("Error: \(error)")
}

from recombee_api_client.api_client import RecombeeClient, Region
from recombee_api_client.api_requests import *

client = RecombeeClient('myDb', private_token, region=Region.US_WEST)
client.send(AddDetailView("2c169e", "xyz", timestamp="2014-07-20T02:49:45+02:00", cascade_create=True))

require 'recombee_api_client'
include RecombeeApiClient

client = RecombeeClient.new('myDb', private_token, {:region => 'us-west'})
client.send(AddDetailView.new('2c169e', 'xyz', {'timestamp' => '2014-07-20T02:49:45+02:00', 'cascadeCreate' => true}))

RecombeeClient client = new RecombeeClient("myDb", privateToken).setRegion(Region.US_WEST);
client.send(new AddDetailView("2c169e", "xyz")
	.setTimestamp(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2016-12-09 13:05:06") )
	.setCascadeCreate(true));

use Recombee\RecommApi\Client;
use Recombee\RecommApi\Requests as Reqs;

$client = new Client("myDb", private_token, ['region' => 'us-west']);
$client -> send(new Reqs\AddDetailView("2c169e", "xyz", ['timestamp' => "2014-07-20T02:49:45+02:00", 'cascadeCreate' => true]));

using Recombee.ApiClient;
using Recombee.ApiClient.ApiRequests;
using Recombee.ApiClient.Bindings;
using Recombee.ApiClient.Util;

var client = new RecombeeClient("myDb", privateToken, region: Region.UsWest);
var datetime = DateTime.Parse("2014-07-20T02:49:45+02:00", null, System.Globalization.DateTimeStyles.RoundtripKind);
client.Send(new AddDetailView("2c169e", "xyz", timestamp: datetime, cascadeCreate: true));

var recombee = require('recombee-api-client');
var rqs = recombee.requests;

var client = new recombee.ApiClient('myDb', privateToken, { region: 'us-west' });
await client.send(
    new rqs.AddDetailView('2c169e', 'xyz', {
        timestamp: '2014-07-20T02:49:45+02:00',
        cascadeCreate: true,
    }),
);

import (
    "github.com/recombee/go-api-client/v6/recombee"
    "time"
)

client, err := recombee.NewRecombeeClient("myDb", privateToken, "us-west")
if err != nil {
    panic(err)
}

_, err = client.NewAddDetailView("2c169e", "xyz").SetCascadeCreate(true).SetTimestamp(time.Unix(1712042581, 0)).Send()

POST /myDb/detailviews/ HTTP/1.0
Host: Based on the region of your DB, see https://docs.recombee.com/regions
Content-type: application/json

Body:
{
	"itemId": "xyz",
	"userId": "2c169e",
	"timestamp": "2014-07-20T02:49:45+02:00",
	"cascadeCreate": true
}

client.send(SetItemValues.new('xyz',
    # values
    {
        'title' => 'Television TV2305',
        'description' => 'HD resolution LED TV',
        'price' => 200,
        'categories' => ['Electronics', 'Televisions'],
        'image' => 'http://examplesite.com/products/xyz.jpg',
        'deleted' => false
    },
    # optional parameters
    {
    'cascadeCreate' => true
    }
))

client.send(new SetItemValues("xyz",
            new HashMap<String, Object>() {{
                put("title", "Television TV2305");
                put("description","HD resolution LED TV");
                put("price", 200);
                put("categories", new String[]{"Electronics", "Televisions"});
                put("image", "http://examplesite.com/products/xyz.jpg");
                put("deleted", false);
            }}
        ).setCascadeCreate(true));

$client -> send(new Reqs\SetItemValues("xyz",
    // values
    [
        "title" => "Television TV2305",
        "description" => "HD resolution LED TV",
        "price" => 200,
        "categories" => ["Electronics", "Televisions"],
        "image" => "http://examplesite.com/products/xyz.jpg",
        "deleted" => false
    ],
    //optional parameters
    [
        "cascadeCreate" => true
    ]
));

client.Send(new SetItemValues("xyz",
    new Dictionary<string, object>() {
        {"title", "Television TV2305"},
        {"description","HD resolution LED TV"},
        {"price", 200},
        {"categories", new string[] {"Electronics", "Televisions"}},
        {"image", "http://examplesite.com/products/xyz.jpg"},
        {"deleted", false}
    },
    cascadeCreate: true
));

await client.send(
    new rqs.SetItemValues(
        'xyz',
        // values
        {
            title: 'Television TV2305',
            description: 'HD resolution LED TV',
            price: 200,
            categories: ['Electronics', 'Televisions'],
            image: 'http://examplesite.com/products/xyz.jpg',
            deleted: false,
        },
        // optional parameters
        {
            cascadeCreate: true,
        },
    ),
);

_, err = client.NewSetItemValues("xyz", map[string]interface{}{
    "title":       "Television TV2305",
    "description": "HD resolution LED TV",
    "price":       200,
    "categories":  []string{"Electronics", "Televisions"},
    "deleted":     false,
    "image":       "http://examplesite.com/products/xyz.jpg",
}).SetCascadeCreate(true).Send()

POST /myDb/items/xyz HTTP/1.0
Host: rapi.recombee.com
Content-type: application/json

Body:
{
    "title": "Television TV2305",
    "description": "HD resolution LED TV",
    "price": 200,
    "categories": ["Electronics", "Televisions"],
    "deleted": false,
    "image": "http://examplesite.com/products/xyz.jpg",
    "!cascadeCreate": true
}

val result = client.sendAsync(RecommendItemsToUser("2c169e", 5))

result.onSuccess { response: RecommendationResponse ->
    for (recommendedItem in response.recomms) {
        println("ID: ${recommendedItem.id}")
    }
}.onFailure { exception -> // ApiException
    println("Exception: $exception")
    // use fallback ...
}

let request = RecommendItemsToUser(
    userId: "2c169e",
    count: 5
)

do {
    let response = try await client.send(request)
    for recommendedItem in response.recomms {
        print("ID: \(recommendedItem.id)")
    }
} catch {
    print("Exception: \(error)")
    // use fallback ...
}

recommended = client.send(RecommendItemsToUser('2c169e', 5))

recommended = client.send(RecommendItemsToUser.new('2c169e', 5))

RecommendationResponse recommended = client.send(new RecommendItemsToUser("2c169e", 5));
//There are two easy ways for getting individual recommendations:
// 1. using getIds() method
String[] recomms = recommended.getIds();

// 2. iterating over recommendations
for(Recommendation r: recommended)
{
    r.getId();
}

$recommended = $client -> send(new Reqs\RecommendItemsToUser("2c169e", 5));

RecommendationResponse recommended = client.Send(new RecommendItemsToUser("2c169e", 5));
// Iterating over recommendations:
foreach(Recommendation r in recommended.Recomms)
{
    Console.WriteLine(r.Id);
}

const recommended = await client.send(new rqs.RecommendItemsToUser('2c169e', 5));

recommendReq := client.NewRecommendItemsToUser("2c169e", 5)

recommendRes, err := recommendReq.Send()
if err != nil {
    panic(err)
}

for _, rec := range recommendRes.Recomms {
    fmt.Println(rec.Id)
}

GET /myDb/recomms/users/2c169e/items/?count=5

val request = RecommendItemsToItem(
    itemId = "xyz",
    targetUserId = "2c169e",
    count = 10,
    scenario = "product_detail",
    returnProperties = true,
    cascadeCreate = true
)

val result = sendAsync(request)
result.onSuccess { response: RecommendationResponse ->
    for (recommendedItem in response.recomms) {
        println("ID: ${recommendedItem.id}")
    }
}.onFailure { exception -> // ApiException
    println("Exception: $exception")
    // use fallback ...
}

let request = RecommendItemsToItem(
    itemId: "xyz",
    targetUserId: "2c169e",
    count: 10,
    scenario: "product_detail",
    cascadeCreate: true,
    returnProperties: true
)


do {
    let response = try await client.send(request)
    for recommendedItem in response.recomms {
        print("ID: \(recommendedItem.id)")
    }
} catch {
    print("Exception: \(error)")
    // use fallback ...
}

recommended = client.send(RecommendItemsToItem('xyz', '2c169e', 10,
                                                scenario='product_detail',
                                                return_properties=True,
                                                cascade_create=True))

recommended = client.send(RecommendItemsToItem.new('xyz', '2c169e', 10,
    {
    'scenario' => 'product_detail',
    'returnProperties' => true,
    'cascadeCreate' => true
    })
)

RecommendationResponse recommended = client.send(new RecommendItemsToItem("xyz", "2c169e", 10))
.setScenario("product_detail")
.setReturnProperties(true)
.setCascadeCreate(true);

$recommended = $client -> send(new Reqs\RecommendItemsToItem('xyz', '2c169e', 10,
                                                        [
                                                            'scenario' => 'product_detail',
                                                            'returnProperties' => true,
                                                            'cascadeCreate' => true
                                                        ])
                            );

RecommendationResponse recommended = client.Send(new RecommendItemsToItem("xyz", "2c169e", 10,
scenario: "product_detail",
returnProperties: true,
cascadeCreate: true));

const recommended = await client.send(
    new rqs.RecommendItemsToItem('xyz', '2c169e', 10, {
        scenario: 'product_detail',
        returnProperties: true,
        cascadeCreate: true,
    }),
);

recommendReq := client.NewRecommendItemsToItem("xyz", "2c169e", 10).
    SetScenario("product_detail").
    SetReturnProperties(true).
    SetCascadeCreate(true)

recommendRes, err := recommendReq.Send()

GET /myDb/recomms/items/xyz/items/?count=10&targetUserId=2c169e&scenario=product_detail&returnProperties=true&cascadeCreate=true

val request = SearchItems(
    userId = "user-13434",
    searchQuery = "search query",
    count = 5,
    scenario = "search_top",
    returnProperties = true,
    cascadeCreate = true
)

client.send(request,
    { response: SearchResponse ->
        // Handle successful response here...
    },
    { exception: ApiException ->
        // Handle exception here...
    }
)

let request = SearchItems(
    userId: "user-13434",
    searchQuery: "search query",
    count: 5,
    scenario: "search_top",
    cascadeCreate: true,
    returnProperties: true
)

do {
    let response: SearchResponse = try await client.send(request)
    // Handle successful response here...
    print("Search response: \(response)")
} catch {
    // Handle error here...
}

matches = client.send(SearchItems('user-13434', 'search query', 5,
                                scenario='search_top',
                                return_properties=True,
                                cascade_create=True))

matches = client.send(SearchItems.new('user-13434', 'search query', 5,
    {
    'scenario' => 'search_top',
    'returnProperties' => true,
    'cascadeCreate' => true
    })
)

SearchResponse matches = client.send(new SearchItems("user-13434", "search query", 5))
.setScenario("search_top")
.setReturnProperties(true)
.setCascadeCreate(true);

$matches = $client -> send(new Reqs\SearchItems('user-13434', 'search query', 5,
                                                    [
                                                        'scenario' => 'search_top',
                                                        'returnProperties' => true,
                                                        'cascadeCreate' => true
                                                    ])
                              );

SearchResponse matches = client.Send(new SearchItems("user-13434", "search query", 5,
scenario: "search_top",
returnProperties: true,
cascadeCreate: true));

const matches = await client.send(
    new rqs.SearchItems('user-13434', 'search query', 5, {
        scenario: 'search_top',
        returnProperties: true,
        cascadeCreate: true,
    }),
);

searchReq := client.NewSearchItems("user-13434", "search query", 5).
    SetScenario("search_top").
    SetReturnProperties(true).
    SetCascadeCreate(true)

searchRes, err := searchReq.Send()

GET /myDb/search/users/user-13434/items/?searchQuery=query&scenario=search_top&returnProperties=true&cascadeCreate=true