Update API Key | Ruby API Client V1 (Deprecated)

1
2
3
4
5
6
7
8
9
10
# Update an existing API key that is valid for 300 seconds
res = Algolia.update_api_key('myAPIKey', ['search'], 300)
puts res['key']
# Update an existing 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'
res = index.update_api_key('myAPIKey', ['search'], 300, 100, 20, ['my_index1', 'my_index2'])
puts res['key']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Update an existing API key that is valid for 300 seconds
client.updateApiKey('myAPIKey', {
  validity: 300,
}).then(({ key }) => {
  console.log(key);
});

// Update an existing 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
client.updateApiKey('myAPIKey', {
  validity: 300,
  maxQueriesPerIPPerHour: 100,
  maxHitsPerQuery: 20,
}).then(({ key }) => {
  console.log(key);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Update an existing API key that is valid for 300 seconds
res = client.update_api_key('myAPIKey', {
    'validity': 300,
})

print('key=%s' % res['key'])

# Update an existing 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
res = client.update_api_key('myAPIKey', {
    'validity': 300,
    'maxQueriesPerIPPerHour': 100,
    'maxHitsPerQuery': 20,
})

print('key=%s' % res['key'])

1
2
3
4
5
6
7
8
9
10
11
12
13
// Update an existing 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 parameters = APIKeyParameters(ACLs: [.search])
  .set(\.indices, to: ["dev_*"])
  .set(\.maxHitsPerQuery, to: 20)
  .set(\.maxQueriesPerIPPerHour, to: 100)
  .set(\.validity, to: 300)

client.updateAPIKey("myAPIKey", with: parameters) { 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
20
21
22
23
24
25
26
27
28
29
30
// Update an existing API key that is valid for 300 seconds
ApiKey apiKeyToUpdate = new ApiKey
{
    Value = "myAPIKey",
    MaxHitsPerQuery = 0,
    MaxQueriesPerIPPerHour = 0,
    Validity = 300
};

var res = client.UpdateApiKey(apiKeyToUpdate);

// Asynchronous
var res = await client.UpdateApiKeyAsync(apiKeyToUpdate);

// Update an existing 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 apiKeyToUpdate = new ApiKey
{
    Value = "myAPIKey",
    Acl = new List<string> { "search" },
    Indexes = new List<string> { "dev_*" },
    MaxHitsPerQuery = 20,
    MaxQueriesPerIPPerHour = 100,
    Validity = 300
};

var res = index.UpdateApiKey(apiKeyToUpdate);

// Asynchronous
var res = await index.UpdateApiKeyAsync(apiKeyToUpdate);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Creates a new API key that is valid for 300 seconds

ApiKey apiKey = new ApiKey()
    .setValue("myApiKey")
    .setAcl(Collections.singletonList("search"))
    .setValidity(300);

client.updateApiKey(apiKey);

// Async 
client.updateApiKeyAsync(apiKey);

// Update a 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 apiKey = new ApiKey()
    .setValue("myApiKey")
    .setAcl(Arrays.asList("search"))
    .setValidity(300L)
    .setMaxQueriesPerIPPerHour(200)
    .setMaxHitsPerQuery(20);

client.updateApiKey(apiKey);

// Async
client.updateApiKeyAsync(apiKey);

1
2
3
4
5
6
7
8
9
10
11
12
// Update an existing 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 := []interface{}{
  "acl":                    []string{"search"},
  "indexes":                []string{"myIndex"},
  "validity":               300,
  "maxQueriesPerIPPerHour": 100,
  "maxHitsPerQuery":        20,
}

res, err := client.UpdateAPIKey("f420238212c54dcfad07ea0aa6d5c45f", params)
fmt.Println(res.Key)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Creates a new API key that is valid for 300 seconds
client.execute {
  update key "myAPIKey" `with` ApiKey(
      acl = Some(Seq(Acl.search)),
      maxHitsPerQuery = Some(0)),
      maxQueriesPerIPPerHour = Some(0),
      validity = Some(300)
  )
}

// Update a index specific API key valid for 300 seconds,
// with a rate limit of 100 calls per hour per IP and a

val apiKey = ApiKey(
  acl = Some(Seq(Acl.search)),
  maxHitsPerQuery = Some(100)),
  maxQueriesPerIPPerHour = Some(100),
  validity = Some(300)
)

client.execute {
  update key "myAPIKey" `with` apiKey from "myIndex"
}

1
2
3
4
5
6
7
8
9
10
11
// Update an existing 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
val apiKey = APIKeyParams(
    ACLs = listOf(ACL.Search),
    indices = listOf(IndexName("dev_*")),
    maxHitsPerQuery = 20,
    maxQueriesPerIPPerHour = 100,
    validity = 300
)

client.updateAPIKey(APIKey("myAPIKey"), apiKey)