Skip to content

Sandbox

A sandbox is a LexOpti organization isolated from real organizations, for development, continuous integration or a demonstration. Your application works there exactly as with a real organization: OAuth, /v1, embedded components and MCP server. Developer and professional accounts are separate: if you already use LexOpti as a professional, create your developer account with another e-mail address.

Property Value
Per application 5 at most, each with a name unique within the application
First sandbox created with your application, in the developer console or by LexOpti when it registers it, owned by your developer account
Others created by the application’s developer, from Manage sandboxes in the organization selector
Profession chosen at creation (lawyer, notary, accountant, estate agent, other regulated profession): it sets the vocabulary, the case natures, the party roles and the classification questionnaire
Marker a translated Sandbox badge in the selector and on the authorization page, a banner on every page; the name carries no marker
GET /v1/organization sandbox: true
Webhook payloads livemode: false
Simulated Real
Checks: every screened entity gets a deterministic result, no source is consulted, no job runs Webhooks to your own endpoints
Company lookups and addresses: fictional answers Invitations of colleagues
Billing: nothing is billed nor drawn; each case, check or party is priced and charged as a real organization’s (the same previews, credits_charged, twelve months of coverage, renewals), but the balance stays at its 1,000 free credits and the movements stay empty; a reset gives them back after quota_exhausted
Ongoing vigilance: never scheduled

Use a keyword in the person’s last name or in the company name (case and accents ignored), or a reserved SIREN:

Keyword SIREN Result
SANCTION 999000011 sanctions hits (international, EU, French asset freezes) and alerts
EXPOSE 999000029 politically exposed person and an alert
PROCEDURE 999000037 BODACC insolvency proceedings and alerts
PRESSE 999000045 adverse media and an alert
ERREUR 999000052 every source fails: check.failed
anything else any other clean

All names in results are your own fictional inputs.

The same inputs settle the free preliminary screening of the clients your application creates, at once and without consulting the lists: SANCTION gives a possible match on the French freeze register and an OFAC match, ERREUR a failed screening, anything else no match.

A sandbox is not empty: at its creation, and again after every reset, it holds example clients and cases covering each magic input, already screened with the sandbox’s results, so your application reads realistic data at once (GET /v1/clients, GET /v1/cases, GET /v1/alerts). Every name is fictitious.

Example Kind Magic input Result
Camille EXEMPLE person, client none clean
Léa EXEMPLE-SANCTION person, client SANCTION sanctions hits and their pending alerts
Hugo EXEMPLE-EXPOSE person, client EXPOSE politically exposed person and its alert
EXEMPLE PRESSE SAS company, client PRESSE, 999000045 adverse media and its alert
EXEMPLE PROCEDURE SARL company, client PROCEDURE, 999000037 BODACC insolvency proceedings and their alerts
EXEMPLE ERREUR SAS company, client ERREUR, 999000052 every screening failed
Example: sale of an apartment case of Camille EXEMPLE parties: Paul EXEMPLE-PRESSE (seller), EXEMPLE IMMOBILIER SCI (buyer) the seller’s adverse media raises an alert on Camille EXEMPLE
Example: transfer of shares case of EXEMPLE PROCEDURE SARL party: Inès EXEMPLE (transferee) clean party

The cases’ nature and the parties’ roles follow the sandbox’s profession; the case labels are in its owner’s language. The clients Camille EXEMPLE and Léa EXEMPLE-SANCTION also hold a preliminary screening, with no match and with a possible match. Writing the examples sends nothing: no event, no webhook.

POST /v1/sandbox/triggers makes something happen in the sandbox as it would in a real organization, through the same writes, so your endpoints receive the very webhooks production sends (livemode: false). It needs lexopti:write, a member who may write, and answers 202 with the events to expect; anywhere but a sandbox it answers 403 sandbox_required and changes nothing.

type Needs What happens Events
vigilance_alert client_id a new adverse media result on the client raises a pending alert alert.created, and client.vigilance_level_changed when the level moves
vigilance_level_change client_id the client’s vigilance level moves up to enhanced, or, from enhanced, back down; no alert client.vigilance_level_changed
quota_exhausted nothing the organization’s last credit is spent, and the sandbox stays without credits: every case, check or party that costs is refused with quota_exceeded, as for a real organization, what is already paid keeps running quota.exhausted
quota_restored nothing the sandbox gets its 1,000 free credits back, after quota_exhausted none
access_revoked nothing your application loses its access to the sandbox for real: every member’s consent and token there are deleted, so the token of this very request stops working access.revoked, then your endpoints are disabled with disabled_reason: access_revoked

The events a write tells come at once; those the dispatcher derives (client.vigilance_level_changed, access.revoked) within about ten seconds. After access_revoked, authorize the application again and enable your endpoints (PATCH /v1/webhook-endpoints/{id} with enabled: true).

import {
function createLexOptiClient(options: LexOptiClientOptions): LexOptiClient

A typed client of the LexOpti API. Every idempotent POST gets an Idempotency-Key (kept across its retries); only requests safe to repeat are retried after a failure, with jittered backoff or Retry-After. Errors are oRPC errors: problemOf(error) reads the problem details.

createLexOptiClient
} from "@lexopti/sdk";
const
const lexopti: LexOptiClient
lexopti
=
function createLexOptiClient(options: LexOptiClientOptions): LexOptiClient

A typed client of the LexOpti API. Every idempotent POST gets an Idempotency-Key (kept across its retries); only requests safe to repeat are retried after a failure, with jittered backoff or Retry-After. Errors are oRPC errors: problemOf(error) reads the problem details.

createLexOptiClient
({
LexOptiClientOptions.accessToken: () => Promise<string> | string

Returns the OAuth access token for each request: refresh it there when it expires (access tokens live 15 minutes).

accessToken
: () =>
function getAccessToken(): Promise<string>
getAccessToken
() });
// A new vigilance alert on a client of the sandbox.
const
const trigger: {
type: "access_revoked" | "vigilance_alert" | "vigilance_level_change" | "quota_exhausted" | "quota_restored";
client_id: string | null;
events: string[];
vigilance_level: "simplified" | "standard" | "enhanced" | null;
livemode: false;
}
trigger
= await
const lexopti: LexOptiClient
lexopti
.
sandboxTriggers: {
create: Client<Record<never, never>, {
type: "access_revoked" | "vigilance_alert" | "vigilance_level_change" | "quota_exhausted" | "quota_restored";
client_id?: string | undefined;
}, {
type: "access_revoked" | "vigilance_alert" | "vigilance_level_change" | "quota_exhausted" | "quota_restored";
client_id: string | null;
events: string[];
vigilance_level: "simplified" | "standard" | "enhanced" | null;
livemode: false;
}, Error>;
}
sandboxTriggers
.
create: Client
(input: {
type: "access_revoked" | "vigilance_alert" | "vigilance_level_change" | "quota_exhausted" | "quota_restored";
client_id?: string | undefined;
}, options?: FriendlyClientOptions<Record<never, never>> | undefined) => ClientPromiseResult<{
type: "access_revoked" | "vigilance_alert" | "vigilance_level_change" | "quota_exhausted" | "quota_restored";
client_id: string | null;
events: string[];
vigilance_level: "simplified" | "standard" | "enhanced" | null;
livemode: false;
}, Error>
create
({
type: "access_revoked" | "vigilance_alert" | "vigilance_level_change" | "quota_exhausted" | "quota_restored"
type
: "vigilance_alert",
client_id?: string | undefined
client_id
:
const clientId: string
clientId
,
});
var console: Console

The console module provides a simple debugging console that is similar to the JavaScript console mechanism provided by web browsers.

The module exports two specific components:

  • A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
  • A global console instance configured to write to process.stdout and process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently synchronous like the browser APIs they resemble, nor are they consistently asynchronous like all other Node.js streams. See the note on process I/O for more information.

Example using the global console:

console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
// Error: Whoops, something bad happened
// at [eval]:5:15
// at Script.runInThisContext (node:vm:132:18)
// at Object.runInThisContext (node:vm:309:38)
// at node:internal/process/execution:77:19
// at [eval]-wrapper:6:22
// at evalScript (node:internal/process/execution:76:60)
// at node:internal/main/eval_string:23:3
const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr

Example using the Console class:

const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);
myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err
const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err

@see ― source

console
.
Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)

Prints to stdout with newline. Multiple arguments can be passed, with the first used as the primary message and all additional used as substitution values similar to printf(3) (the arguments are all passed to util.format()).

const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout

See util.format() for more information.

@since ― v0.1.100

log
(
const trigger: {
type: "access_revoked" | "vigilance_alert" | "vigilance_level_change" | "quota_exhausted" | "quota_restored";
client_id: string | null;
events: string[];
vigilance_level: "simplified" | "standard" | "enhanced" | null;
livemode: false;
}
trigger
.
events: string[]
events
);
Action Who Where
Open, switch any member of the sandbox the Sandboxes section of the organization selector
Leave any member who also belongs to a real organization Leave the sandbox in the banner: back to the last real organization made active
Invite a colleague its owner or an administrator the sandbox’s members page, with the ordinary invitations; a sandbox membership opens no real organization
Create the application’s developer Manage sandboxes, 5 per application at most
Rename, reset, delete its owner (its creator, or the member it was transferred to) Manage sandboxes; reset also in the banner

LexOpti can also reset or delete a sandbox for you. Every change is recorded in the sandbox’s activity, or in the platform’s audit trail when LexOpti makes it.

A reset empties the sandbox in place, in one transaction, then writes the example data again, with new ids:

Kept Erased
the organization and its id clients, cases, entities and their links
its members and pending invitations checks, screenings, alerts and alert proposals
your application’s consent and tokens: nothing to reconnect classifications and TRACFIN forms
your webhook endpoints and their secrets comments, documents and reports
events and past deliveries (GET /v1/events) the sandbox’s whole activity history (creation, renames, earlier resets, every change to a record): it starts again with this reset alone
membership notifications (invitations, join requests) notifications about records (screenings, alerts, cases, comments)
your external_ref, idempotency keys, deep links and embed session codes
  • The old client, case and check ids answer 404 not_found on /v1, in embedded components and in MCP tools, never 500.
  • Deliveries still pending are cancelled, and events not yet sent never will be: a reset sends nothing. The events the reset itself would write (about the records it erases, or the examples it writes) are not recorded.
  • At most one reset a minute per sandbox: another one is refused until the minute is over.
  • LexOpti’s audit trail of the platform’s own actions on the sandbox is kept; only the sandbox’s activity history goes.

Deleting a sandbox erases it for good, with every member’s access and every application’s: it cannot be undone.