Reactors
Create Reactor
Create a new Reactor for the Tenant.
Permissions
reactor:create
Request
- cURL
- Node
- JavaScript (legacy)
- C#
- Java
- Python
- Go
javascript='module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: "bar"
}
};
};'
curl "https://api.basistheory.com/reactors" \
-H "BT-API-KEY: <MANAGEMENT_API_KEY>" \
-H "Content-Type: application/json" \
-X "POST" \
-d '{
"name": "My Reactor",
"code": '"$(echo $javascript | jq -Rsa .)"',
"configuration": {
"SERVICE_API_KEY": "key_abcd1234"
},
"application": {
"id": "45c124e7-6ab2-4899-b4d9-1388b0ba9d04"
}
}'
await client.reactors.create({
name: "My Reactor",
code: `
module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: "bar"
}
};
};
`,
configuration: {
SERVICE_API_KEY: "key_abcd1234",
},
application: {
id: applicationId,
}
})
import { BasisTheory } from "@basis-theory/basis-theory-js";
const bt = await new BasisTheory().init("<MANAGEMENT_API_KEY>");
const reactor = await bt.reactors.create({
name: "My Reactor",
code: `
module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: "bar"
}
};
};
`,
configuration: {
SERVICE_API_KEY: "key_abcd1234",
},
application: {
id: "45c124e7-6ab2-4899-b4d9-1388b0ba9d04",
},
});
await client.Reactors.CreateAsync(new CreateReactorRequest
{
Name = "My Reactor",
Code = @"
module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: ""bar""
}
};
};",
Configuration = new Dictionary<string, string?>
{
{ "SERVICE_API_KEY", "key_abcd1234" }
},
Application = new Application
{
Id = applicationId
}
});
new ReactorsClient(ClientOptions.builder().build()).create(CreateReactorRequest.builder()
.name("My Reactor")
.code("...")
.configuration(new HashMap<>())
.application(Application.builder().id("applicationId").build())
.build());
client.reactors.create(
name='My Reactor',
code="""module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: "bar"
}
};
};""",
configuration={
"SERVICE_API_KEY": "key_abcd1234"
},
application={
"id": application_id
}
)
code := `module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: "bar"
}
};
};`
reactor, err := client.Reactors.Create(ctx, &basistheory.CreateReactorRequest{
Name: "My Reactor",
Code: code,
Configuration: map[string]*string{
"SERVICE_API_KEY": func(s string) *string { return &s }("key_abcd1234"),
},
Application: &basistheory.Application{
ID: applicationID,
},
})
Request Parameters
Attribute | Required | Type | Default | Description |
---|---|---|---|---|
name | true | string | null | The name of the reactor. Has a maximum length of 200 |
code | true | string | null | Reactor code which will be executed when the Reactor is processed |
configuration | true | map<string, string> | null | A string key and string value map of predefined configuration names and values accessible from the Reactor code |
application.id | false | uuid | null | This Application's API key is injected into a pre-configured BasisTheory JS SDK instance passed into the Reactor's runtime. Must be a public or private Application Type. |
Response
Returns a Reactor if the Reactor was created. Returns an error if there were validation errors, or the Reactor failed to create.
{
"id": "5b493235-6917-4307-906a-2cd6f1a90b13",
"tenant_id": "77cb0024-123e-41a8-8ff8-a3d5a0fa8a08",
"name": "My Reactor",
"code": "
module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: 'bar',
}
};
};
",
"application": {...},
"configuration": {
"SERVICE_API_KEY": "key_abcd1234"
},
"created_by": "3ce0dceb-fd0b-4471-8006-c51243c9ef7a",
"created_at": "2020-09-15T15:53:00+00:00"
}
List Reactors
Get a list of reactors for the Tenant.
Permissions
reactor:read
Request
- cURL
- Node
- JavaScript (legacy)
- C#
- Java
- Python
- Go
curl "https://api.basistheory.com/reactors" \
-H "BT-API-KEY: <MANAGEMENT_API_KEY>"
const response = await client.reactors.list();
for await (const item of response) {
console.log(item);
}
// Or you can manually iterate page-by-page
const page = await client.reactors.list();
while (page.hasNextPage()) {
page = page.getNextPage();
}
import { BasisTheory } from "@basis-theory/basis-theory-js";
const bt = await new BasisTheory().init("<MANAGEMENT_API_KEY>");
const reactors = await bt.reactors.list();
await client.Reactors.ListAsync(new ReactorsListRequest());
new ReactorsClient(ClientOptions.builder().build()).list();
response = client.reactors.list()
for item in response:
yield item
# alternatively, you can paginate page-by-page
for page in response.iter_pages():
yield page
// List all reactors
reactors, err := client.Reactors.List(ctx, &basistheory.ReactorsListRequest{})
Query Parameters
Parameter | Required | Type | Default | Description |
---|---|---|---|---|
id | false | array | [] | An optional list of Reactor ID's to filter the list of reactors by |
name | false | string | null | Wildcard search of reactors by name |
Response
Returns a paginated object with the data
property containing an array of reactors. Providing any query parameters will filter the results. Returns an error if reactors could not be retrieved.
{
"pagination": {...}
"data": [
{
"id": "5b493235-6917-4307-906a-2cd6f1a90b13",
"tenant_id": "77cb0024-123e-41a8-8ff8-a3d5a0fa8a08",
"name": "My Reactor",
"code": "
module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: 'bar',
}
};
};
",
"configuration": {
"SERVICE_API_KEY": "key_abcd1234"
},
"created_by": "fb124bba-f90d-45f0-9a59-5edca27b3b4a",
"created_at": "2020-09-15T15:53:00+00:00",
"modified_by": "fb124bba-f90d-45f0-9a59-5edca27b3b4a",
"modified_at": "2021-03-01T08:23:14+00:00"
},
{...},
{...}
]
}
Get a Reactor
Get a Reactor by ID in the Tenant.
Permissions
reactor:read
Request
- cURL
- Node
- JavaScript (legacy)
- C#
- Java
- Python
- Go
curl "https://api.basistheory.com/reactors/5b493235-6917-4307-906a-2cd6f1a90b13" \
-H "BT-API-KEY: <MANAGEMENT_API_KEY>"
await client.reactors.get("id");
import { BasisTheory } from "@basis-theory/basis-theory-js";
const bt = await new BasisTheory().init("<MANAGEMENT_API_KEY>");
const reactor = await bt.reactors.retrieve(
"5b493235-6917-4307-906a-2cd6f1a90b13"
);
await client.Reactors.GetAsync("id");
new ReactorsClient(ClientOptions.builder().build()).get("id");
client.reactors.get(
id="id",
)
reactor, err := client.Reactors.Get(ctx, "id")
URI Parameters
Parameter | Required | Type | Default | Description |
---|---|---|---|---|
id | true | uuid | null | The ID of the reactor |
Response
Returns a Reactor with the id
provided. Returns an error if the Reactor could not be retrieved.
{
"id": "5b493235-6917-4307-906a-2cd6f1a90b13",
"tenant_id": "77cb0024-123e-41a8-8ff8-a3d5a0fa8a08",
"name": "My Reactor",
"code": "
module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: 'bar',
}
};
};
",
"configuration": {
"SERVICE_API_KEY": "key_abcd1234"
},
"created_by": "fb124bba-f90d-45f0-9a59-5edca27b3b4a",
"created_at": "2020-09-15T15:53:00+00:00",
"modified_by": "fb124bba-f90d-45f0-9a59-5edca27b3b4a",
"modified_at": "2021-03-01T08:23:14+00:00"
}
Update Reactor
Update a Reactor by ID in the Tenant.
Permissions
reactor:update
Request
- cURL
- Node
- JavaScript (legacy)
- C#
- Java
- Python
- Go
javascript='module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: "bar"
}
};
};'
curl "https://api.basistheory.com/reactors/5b493235-6917-4307-906a-2cd6f1a90b13" \
-H "BT-API-KEY: <MANAGEMENT_API_KEY>" \
-H "Content-Type: application/json" \
-X "PUT" \
-d '{
"name": "My Reactor",
"code": '"$(echo $javascript | jq -Rsa .)"',
"configuration": {
"SERVICE_API_KEY": "key_abcd1234"
},
"application": {
"id": "45c124e7-6ab2-4899-b4d9-1388b0ba9d04"
}
}'
await client.reactors.update(
reactorId,
{
name: "My Reactor",
code: `
module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: "bar"
}
};
};
`,
configuration: {
SERVICE_API_KEY: "key_abcd1234",
},
application: {
id: applicationId,
}
}
);
import { BasisTheory } from "@basis-theory/basis-theory-js";
const bt = await new BasisTheory().init("<MANAGEMENT_API_KEY>");
const reactor = await bt.reactors.update(
"5b493235-6917-4307-906a-2cd6f1a90b13",
{
name: "My Reactor",
code: '
module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: "bar"
}
};
};
',
configuration: {
SERVICE_API_KEY: "key_abcd1234",
},
application: {
id: "45c124e7-6ab2-4899-b4d9-1388b0ba9d04",
},
}
);
await client.Reactors.UpdateAsync(
reactorId,
new UpdateReactorRequest
{
Name = "My Reactor",
Code = @"
module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: ""bar""
}
};
};",
Configuration = new Dictionary<string, string?>
{
{ "SERVICE_API_KEY", "key_abcd1234" }
},
Application = new Application
{
Id = applicationId
}
}
);
new ReactorsClient(ClientOptions.builder().build()).update("id", UpdateReactorRequest.builder()
.name("My Reactor")
.code("...")
.configuration(new HashMap<>())
.application(Application.builder().id("applicationId").build())
.build());
client.reactors.update(
id = reactor_id,
name='My Reactor',
code="""module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: "bar"
}
};
};""",
configuration={
"SERVICE_API_KEY": "key_abcd1234"
},
application={
"id": application_id
}
)
code := `module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: "bar"
}
};
};`
reactor, err := client.Reactors.Update(ctx, reactorId, &basistheory.UpdateReactorRequest{
Name: "My Reactor",
Code: code,
Configuration: map[string]*string{
"SERVICE_API_KEY": func(s string) *string { return &s }("key_abcd1234"),
},
})
URI Parameters
Parameter | Required | Type | Default | Description |
---|---|---|---|---|
id | true | uuid | null | The ID of the reactor |
Request Parameters
Attribute | Required | Type | Default | Description |
---|---|---|---|---|
name | true | string | null | The name of the reactor. Has a maximum length of 200 |
code | true | string | null | Reactor code which will be executed when the Reactor is processed |
configuration | true | map<string, string> | null | A string key and string value map of predefined configuration names and values accessible from the Reactor code |
application.id | false | uuid | null | This Application's API key is injected into a pre-configured BasisTheory JS SDK instance passed into the Reactor's runtime. Must be a public or private Application Type. |
Response
Returns a Reactor if the Reactor was updated. Returns an error if there were validation errors, or the Reactor failed to update.
{
"id": "5b493235-6917-4307-906a-2cd6f1a90b13",
"tenant_id": "77cb0024-123e-41a8-8ff8-a3d5a0fa8a08",
"name": "My Reactor",
"code": "
module.exports = async function (req) {
// Do something with req.configuration.SERVICE_API_KEY
return {
raw: {
foo: 'bar'
}
};
};
",
"configuration": {
"SERVICE_API_KEY": "key_abcd1234"
},
"created_by": "fb124bba-f90d-45f0-9a59-5edca27b3b4a",
"created_at": "2020-09-15T15:53:00+00:00",
"modified_by": "34053374-d721-43d8-921c-5ee1d337ef21",
"modified_at": "2021-03-01T08:23:14+00:00"
}
Patch Reactor
Patch a Reactor by ID in the Tenant.
Permissions
reactor:update
Content-Type
header to be set to application/merge-patch+json
. Requests made with a different Content-Type
header value will receive a 415 Unsupported Media Type
response code. For more information on merge-patch, see RFC 7386.Request
- cURL
- Node
- JavaScript (legacy)
- C#
- Java
- Python
- Go
curl "https://api.basistheory.com/reactors/5b493235-6917-4307-906a-2cd6f1a90b13" \
-H "BT-API-KEY: <MANAGEMENT_API_KEY>" \
-H "Content-Type: application/merge-patch+json" \
-X "PATCH" \
-d '{
"name": "My Reactor",
"configuration": {
"SERVICE_API_KEY": "key_abcd1234"
}
}'
await client.reactors.patch(
reactorId!,
{
name: "My Reactor",
configuration: {
SERVICE_API_KEY: "key_abcd1234",
}
}
)
import { BasisTheory } from "@basis-theory/basis-theory-js";
const bt = await new BasisTheory().init("<MANAGEMENT_API_KEY>");
const reactor = await bt.reactors.patch(
"5b493235-6917-4307-906a-2cd6f1a90b13",
{
name: "My Reactor",
configuration: {
SERVICE_API_KEY: "key_abcd1234",
}
}
);
await client.Reactors.PatchAsync(
reactorId,
new PatchReactorRequest
{
Name = "My Reactor",
Configuration = new Dictionary<string, string?>
{
{ "SERVICE_API_KEY", "key_abcd1234" }
}
}
);
new ReactorsClient(ClientOptions.builder().build()).patch("id", PatchReactorRequest.builder()
.name("My Reactor")
.configuration(new HashMap() {{
put("SERVICE_API_KEY", "key_abcd1234");
}})
.build());
client.reactors.patch(
id = reactor_id,
name='My Reactor',
configuration={
"SERVICE_API_KEY": "key_abcd1234"
}
)
err := client.Reactors.Patch(ctx, reactorId, &basistheory.PatchReactorRequest{
Name: "My Reactor",
Configuration: map[string]*string{
"SERVICE_API_KEY": func(s string) *string { return &s }("key_abcd1234"),
},
})
URI Parameters
Parameter | Required | Type | Default | Description |
---|---|---|---|---|
id | true | uuid | null | The ID of the reactor |
Request Parameters
Attribute | Required | Type | Default | Description |
---|---|---|---|---|
name | false | string | null | The name of the reactor. Has a maximum length of 200 |
code | false | string | null | Reactor code which will be executed when the Reactor is processed |
configuration | false | map<string, string> | null | A string key and string value map of predefined configuration names and values accessible from the Reactor code |
application.id | false | uuid | null | This Application's API key is injected into a pre-configured BasisTheory JS SDK instance passed into the Reactor's runtime. Must be a public or private Application Type. |
Response
Returns 204
if successful. Returns an error if there were validation errors, or the operation failed.
Delete Reactor
Delete a Reactor by ID in the Tenant.
Permissions
reactor:delete
Request
- cURL
- Node
- JavaScript (legacy)
- C#
- Java
- Python
- Go
curl "https://api.basistheory.com/reactors/fb124bba-f90d-45f0-9a59-5edca27b3b4a" \
-H "BT-API-KEY: <MANAGEMENT_API_KEY>" \
-X "DELETE"
await client.reactors.delete("id");
import { BasisTheory } from "@basis-theory/basis-theory-js";
const bt = await new BasisTheory().init("<MANAGEMENT_API_KEY>");
await bt.reactors.delete("fb124bba-f90d-45f0-9a59-5edca27b3b4a");
await client.Reactors.DeleteAsync("id");
new ReactorsClient(ClientOptions.builder().build()).delete("id");
client.reactors.delete(
id="id",
)
err := client.Reactors.Delete(ctx, "id")
URI Parameters
Parameter | Required | Type | Default | Description |
---|---|---|---|---|
id | true | uuid | null | The ID of the reactor |
Response
Returns an error if the Reactor failed to delete.
Response
Returns a response object the same as the synchronous response.
Reactor Response Object
Attribute | Type | Description |
---|---|---|
tokens | object | (Optional) Token(s) created from the tokenize block of the Reactor code response |
raw | object | (Optional) Raw output returned from the Reactor |
Reactor Object
Attribute | Type | Description |
---|---|---|
id | uuid | Unique identifier of the Reactor which can be used to get a Reactor |
tenant_id | uuid | The Tenant ID which owns the reactor |
name | string | The name of the reactor |
code | string | Reactor code which will be executed when the Reactor is processed |
configuration | map<string, string> | A string key and string value map of predefined configuration names and values accessible from the Reactor code |
application | Application | (Optional) This Application's API key is injected into a pre-configured BasisTheory JS SDK instance passed into the Reactor's runtime. Must be a public or private Application Type. |
created_by | uuid | (Optional) The ID of the user or Application that created the Reactor |
created_at | string | (Optional) Created date of the Reactor in ISO 8601 format |
modified_by | uuid | (Optional) The ID of the user or Application that last modified the Reactor |
modified_at | date | (Optional) Last modified date of the Reactor in ISO 8601 format |
Reactor Code
All Reactor code
snippets must export a function which takes in a request object and returns a response object.
The snippet should be written in Javascript (targeting Node.js v16) and generally follows the following structure:
module.exports = async function (req) {
const { my_arg } = req.args; // access any args provided with the request
const { MY_CONFIG } = req.configuration; // access any static config defined on the Reactor
// do anything here!
return {
raw: {}, // non-sensitive data that should be returned in plaintext
tokenize: {}, // sensitive data that should be tokenized
};
};
Reactor Code Request Object
Attribute | Type | Description |
---|---|---|
args | object | The arguments that were provided when the reactor was invoked |
configuration | map<string, string> | A string key and string value map of all configuration name and values defined when creating the Reactor |
applicationOptions | object | An object containing configuration information for the @basis-theory/basis-theory-js SDK |
applicationOptions.apiKey | string | An API key for the @basis-theory/basis-theory-js SDK |
applicationOptions.environment | string | The Basis Theory API URL for the @basis-theory/basis-theory-js SDK |
Reactor Code Response Object
Attribute | Type | Description |
---|---|---|
raw | object | (Optional) Raw output returned from the Reactor |
tokenize | object | (Optional) A payload that will be tokenized to produce one or more tokens |
The payload returned in the tokenize
property will be tokenized in the same way that requests are tokenized via the Tokenize endpoint.
For more information, see Tokenize.