curl --request POST \
  --url 'https://api.noresponse.org/v1/assessments' \
  --header "Authorization: Bearer $NORESPONSE_API_KEY" \
  --header 'Content-Type: application/json' \
  --header 'Idempotency-Key: account-acct_7f3a9c' \
  --data '{
  "account_id": "acct_7f3a9c",
  "flow": "account_creation",
  "identifiers": {
    "email": "new.user@example.com"
  }
}'

import { NoResponse } from "@noresponse/node";

const noResponse = new NoResponse({
  apiKey: process.env["NORESPONSE_API_KEY"] ?? "",
});

async function run() {
  const result = await noResponse.assessments.create({
    idempotencyKey: "account-acct_7f3a9c",
    body: {
      accountId: "acct_7f3a9c",
      flow: "account_creation",
      identifiers: {
        email: "new.user@example.com",
      },
    },
  });

  console.log(result);
}

run();

from noresponse import NoResponse
import os


with NoResponse(
    api_key=os.getenv("NORESPONSE_API_KEY", ""),
) as no_response:

    res = no_response.assessments.create(idempotency_key="account-acct_7f3a9c", account_id="acct_7f3a9c", flow="account_creation", identifiers={
        "email": "new.user@example.com",
    }, policy_context={
        "region": "AU",
    }, request_id="req-2026-10-14-0001", client_context={
        "timezone": "Australia/Sydney",
        "locale": "en-AU",
        "app_version": "4.12.0",
        "user_agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0 Safari/537.36",
        "device_id": "dev_5c1e8a",
        "session_id": "sess_9b2d41",
        "client_observed_at": "2026-10-14T08:59:58.000Z",
    }, auth_context={
        "provider": "clerk",
        "issuer": "https://example-app.clerk.accounts.dev",
        "audience": "https://app.example.com",
        "audiences": [
            "https://app.example.com",
        ],
        "subject": "user_2EXAMPLE",
        "session_id": "sess_2EXAMPLE",
        "organization_id": "org_2EXAMPLE",
        "tenant_id": "tenant_2EXAMPLE",
        "token_id": "2EXAMPLEJTI",
        "issued_at": "2026-10-14T08:59:40.000Z",
        "expires_at": "2026-10-14T09:00:40.000Z",
        "session_created_at": "2026-10-14T08:57:00.000Z",
        "auth_time": "2026-10-14T08:55:00.000Z",
        "account_created_at": "2026-10-14T08:56:00.000Z",
        "verified": False,
        "mfa": {
            "methods": [
                "totp",
            ],
        },
        "roles": [
            "admin",
        ],
        "scopes": [
            "org:sys_profile:manage",
        ],
    }, issued_credential={
        "sha256": "2bdbf5c72f2a36df0ef40fb92203612274d4546f56dba946070a6a79c2401a1b",
    })

    # Handle response
    print(res)

package main

import(
	"context"
	"os"
	noresponse "github.com/noresponsehq/go/v5"
	"github.com/noresponsehq/go/v5/models/components"
	"log"
)

func main() {
    ctx := context.Background()

    s := noresponse.New(
        noresponse.WithSecurity(os.Getenv("NORESPONSE_API_KEY")),
    )

    res, err := s.Assessments.Create(ctx, "account-acct_7f3a9c", components.AssessmentRequest{
        AccountID: "acct_7f3a9c",
        Flow: components.FlowAccountCreation,
        Identifiers: components.AssessmentRequestIdentifiers{
            Email: noresponse.Pointer("new.user@example.com"),
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    if res != nil {
        // handle response
    }
}

package hello.world;

import java.lang.Exception;
import org.noresponse.NoResponse;
import org.noresponse.models.errors.AuthenticationException;
import org.noresponse.models.errors.BadRequestException;
import org.noresponse.models.errors.ConflictException;
import org.noresponse.models.errors.NotFoundException;
import org.noresponse.models.errors.PermissionDeniedException;
import org.noresponse.models.errors.RateLimitException;
import org.noresponse.models.operations.CreateAssessmentResponse;
import org.noresponse.models.shared.AssessmentRequest;
import org.noresponse.models.shared.AssessmentRequestIdentifiers;
import org.noresponse.models.shared.Flow;

public class Application {

    public static void main(String[] args) throws Exception {

        NoResponse sdk = NoResponse.builder()
                .apiKey(System.getenv().getOrDefault("NORESPONSE_API_KEY", ""))
            .build();

        CreateAssessmentResponse res = sdk.assessments().create()
                .idempotencyKey("account-acct_7f3a9c")
                .body(AssessmentRequest.builder()
                    .accountId("acct_7f3a9c")
                    .flow(Flow.ACCOUNT_CREATION)
                    .identifiers(AssessmentRequestIdentifiers.builder()
                        .email("new.user@example.com")
                        .build())
                    .build())
                .call();

        if (res.assessment().isPresent()) {
            System.out.println(res.assessment().get());
        }
    }
}

using NoResponse;
using NoResponse.Models.Shared;
using System;

var sdk = new NoResponseClient(apiKey: Environment.GetEnvironmentVariable("NORESPONSE_API_KEY"));

var res = await sdk.Assessments.CreateAsync(
    body: new AssessmentRequest() {
        AccountId = "acct_7f3a9c",
        Flow = Flow.AccountCreation,
        Identifiers = new AssessmentRequestIdentifiers() {
            Email = "new.user@example.com",
        },
    },
    idempotencyKey: "account-acct_7f3a9c"
);

// handle response

<?php

declare(strict_types=1);

require 'vendor/autoload.php';

use NoResponse;
use NoResponse\Models\Shared;

$sdk = NoResponse\NoResponseClient::builder()
    ->setSecurity(
        getenv('NORESPONSE_API_KEY') ?: ''
    )
    ->build();

$body = new Shared\AssessmentRequest(
    accountId: 'acct_7f3a9c',
    flow: Shared\Flow::AccountCreation,
    identifiers: new Shared\AssessmentRequestIdentifiers(
        email: 'new.user@example.com',
    ),
);

$response = $sdk->assessments->create(
    body: $body,
    idempotencyKey: 'account-acct_7f3a9c'

);

if ($response->assessment !== null) {
    // handle response
}

require 'noresponse'

Models = ::NoResponse::Models
s = ::NoResponse::NoResponseClient.new(
  api_key: ENV.fetch('NORESPONSE_API_KEY', '')
)
res = s.assessments.create(body: Models::Shared::AssessmentRequest.new(
  account_id: 'acct_7f3a9c',
  flow: Models::Shared::Flow::ACCOUNT_CREATION,
  identifiers: Models::Shared::AssessmentRequestIdentifiers.new(
    email: 'new.user@example.com'
  )
), idempotency_key: 'account-acct_7f3a9c')

unless res.nil?
  # handle response
end