Add API Key

1
2
3
# Creates a new API key that can only perform search actions
res = client.add_api_key(['search'])
puts res['key']

1
2
3
4
// Creates a new API key that can only perform search actions
client.addApiKey(['search']).then(({ key }) => {
  console.log(key);
});

1
2
3
# Creates a new API key that can only perform search actions
res = client.add_api_key(['search'])
print(res['key'])

1
2
3
4
5
6
7
8
// Creates a new API key that can only perform search actions
let params = APIKeyParameters(ACLs: [.search])

client.addAPIKey(with: params) { result in
  if case .success(let apiKeyCreation) = result {
    print(apiKeyCreation.key)
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Creates a new API key that can only perform search actions
var res = client.AddApiKey(new ApiKey
{
  Acl = new List<string> { "search" }
});

// To make sure the key is added
res.wait();

// Asynchronous
var res = await client.AddApiKeyAsync(new ApiKey
{
  Acl = new List<string> { "search" }
});

// To make sure the key is added
res.wait();

1
2
3
4
5
6
7
8
9
10
11
// Creates a new API key that can only perform search actions
ApiKey apiKey = new ApiKey().setAcl(Collections.singletonList("search")));

// Sync version
AddApiKeyResponse res = client.addApiKey(apiKey);

// To make sure the key is added
res.waiTask();

// Async version
client.addApiKeyAsync(apiKey);

1
2
3
4
5
6
7
8
9
10
11
// Creates a new index specific API key valid for 300 seconds, with a rate
// limit of 100 calls per hour per IP and a maximum of 20 hits
acl := []string{"search"}
params := []interface{}{
  "validity":               300,
  "maxQueriesPerIPPerHour": 100,
  "maxHitsPerQuery":        20,
}

res, err := index.AddAPIKey(acl, params)
fmt.Println(res.Key)

1
2
3
4
5
6
// Creates a new API key that can only perform search actions
client.execute {
  add key ApiKey(
    acl = Some(Seq(Acl.search)),
  )
}

1
2
3
4
5
6
7
8
val params = APIKeyParams(
    ACLs = listOf(ACL.Search)
)
client.apply {
    val response = addAPIKey(params).wait()

    deleteAPIKey(response.apiKey)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Creates a new index specific API key:
#  - valid for 300 seconds
#  - rate limit of 100 calls per hour per IP
#  - maximum of 20 hits
#  - valid on 'my_index1' and 'my_index2'

opts = {
  validity: 300,
  maxQueriesPerIPPerHour: 100,
  maxHitsPerQuery: 20,
  indexes: ['my_index1', 'my_index2'],
  referers: ['algolia.com/*'],
  queryParameters: 'ignorePlurals=false&restrictSources=192.168.1.0/24',
  description: 'Limited search only API key for algolia.com'
}

acl = ['search']
res = client.add_api_key(acl, opts)

puts res['key']

1
2
3
4
5
6
7
8
9
10
11
client.addApiKey(['search'], {
  validity: 300,
  maxQueriesPerIPPerHour: 100,
  maxHitsPerQuery: 20,
  indexes: ['dev_*'],
  referers: ['algolia.com/*'],
  queryParameters: 'ignorePlurals=false&restrictSources=192.168.1.0/24',
  description: 'Limited search only API key for algolia.com'
}).then(({ key }) => {
  console.log(key);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Creates a new index specific API key valid for 300 seconds
# with a rate limit of 100 calls per hour per IP and a maximum of 20 hits

params = {
    'acl': ['search'],
    'validity': 300,
    'maxQueriesPerIPPerHour': 100,
    'maxHitsPerQuery': 20,
    'indexes': ['dev_*'],
    'referers': ['algolia.com/*'],
    'queryParameters': 'ignorePlurals=false&restrictSources=192.168.1.0/24',
    'description': 'Limited search only API key for algolia.com'
}

res = client.add_api_key(['search'], params)
print(res["key"])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Creates a new index specific API key valid for 300 seconds,
// with a rate limit of 100 calls per hour per IP and a maximum of 20 hits

let params = APIKeyParameters(ACLs: [.search])
  .set(\.description, to: "Limited search only API key for algolia.com")
  .set(\.indices, to: ["dev_*"])
  .set(\.maxHitsPerQuery, to: 20)
  .set(\.maxQueriesPerIPPerHour, to: 100)
  .set(\.query, to: Query()
    .set(\.typoTolerance, to: .strict)
    .set(\.ignorePlurals, to: false)
  )
  .set(\.referers, to: ["algolia.com/*"])
  .set(\.validity, to: 300)

client.addAPIKey(with: params) { result in
  if case .success(let response) = result {
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Creates a new index specific API key valid for 300 seconds,
// with a rate limit of 100 calls per hour per IP and a maximum of 20 hits

ApiKey param = new ApiKey
{
    Acl = new List<string> { "search" },
    Description = "Limited search only API key for algolia.com",
    Indexes = new List<string> { "dev_*" },
    MaxHitsPerQuery = 20,
    MaxQueriesPerIPPerHour = 100,
    QueryParameters = "ignorePlurals=false&restrictSources=192.168.1.0/24",
    Referers = new List<string> { "algolia.com/*" },
    Validity = 300,
};

var res = index.AddApiKey(param);

// Asynchronous
var res = await index.AddApiKeyAsync(param);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Creates a new API key that is valid for 300 seconds
ApiKey apiKey = new ApiKey()
  .setAcl(Collections.singletonList("search"))
  .setMaxHitsPerQuery(20)
  .setMaxQueriesPerIPPerHour(100)
  .setValidity(300L)
  .setIndexes(Collections.singletonList("myIndex"))
  .setReferers(Collections.singletonList("algolia.com/*"))
  .setQueryParameters("ignorePlurals=false&restrictSources=192.168.1.0/24")
  .setDescription("Limited search only API key for algolia.com");

// Sync version
AddApiKeyResponse res = client.addApiKey(apiKey);

// To make sure the key is added
res.waiTask();

// Async version
client.addApiKeyAsync(apiKey);

1
2
3
4
5
6
7
8
9
10
11
12
13
// Creates a new index specific API key valid for 300 seconds, with a rate
// limit of 100 calls per hour per IP and a maximum of 20 hits
acl := []string{"search"}
params := []interface{}{
  "indexes":                "myIndex",
  "validity":               300,
  "maxQueriesPerIPPerHour": 100,
  "maxHitsPerQuery":        20,
  "queryParameters":       "ignorePlurals=false&restrictSources=192.168.1.0/24",
}

res, err := client.AddAPIKey(acl, params)
fmt.Println(res.Key)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Creates a new API key that is valid for 300 seconds
val apiKey = ApiKey(
  acl = Some(Seq(Acl.search)),
  maxHitsPerQuery = Some(20)),
  maxQueriesPerIPPerHour = Some(100),
  validity = Some(300),
  indexes = Some(Seq("myIndex")),
  referers = Some(Seq("algolia.com/*")),
  queryParameters = Some(Seq("ignorePlurals=false&restrictSources=192.168.1.0/24")),
  description = Some("Limited search only API key for algolia.com")
)

client.execute {
  add key apiKey
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
val params = APIKeyParams(
    ACLs = listOf(ACL.Search),
    description = "Limited search only API key for algolia.com",
    indices = listOf(IndexName("dev_*")),
    maxHitsPerQuery = 20,
    maxQueriesPerIPPerHour = 100,
    query = Query(
        typoTolerance = TypoTolerance.Strict,
        ignorePlurals = IgnorePlurals.False
    ),
    referers = listOf("algolia.com/*"),
    validity = 300
)
client.apply {
    val response = client.addAPIKey(params, restrictSources = "169.254.0.0/16").wait()

    client.deleteAPIKey(response.apiKey)
}