Claron
    Documentation
    BACKEND SDK · EXPERIMENTALReviewed

    Backend SDK

    Use the backend SDK when your API or application server runs on your own hosting. It adds server context to new review reports. Your backend stays on your infrastructure.

    Before you start

    A backend you host, a Claron project with an active frontend environment, and the updated CLI.

    What you get

    Connect the backend with one setup command, then inspect its requests in a new review.

    Do you need the SDK?

    Where the server runsYour next step
    Supported SSR application built and hosted by ClaronEnable Backend Evidence, then rebuild the SSR application. This captures that app's SSR server; you do not need this separate-backend setup for it.
    Separate API or backend server on your own hostingFollow this guide. Configure that backend and run its collector on your infrastructure. Claron does not host it.
    Static website with no serverThere is no application server to capture. If it calls a separate API you own, connect that API instead.

    Which backends are supported?

    The following integrations are implemented and have passing framework fixtures. Separate-backend capture is experimental: framework support does not mean every runtime version, hosting platform, or application feature is covered. Follow the linked setup requirements for your framework.

    The updated backend SDK and CLI previews are still undergoing pre-publication testing. This table describes the current implementation; check your installed CLI's backend commands before starting setup.

    EcosystemAvailable integrationsSetup path
    JavaScript / TypeScriptExpress, Fastify, Koa, Hono on Node, NestJS, Next.js with webpack on Node, and Elysia on BunCLI setup. Hono's Bun/Deno/edge paths and Next.js Turbopack/edge capture are not covered.
    PythonFlask, FastAPI / Starlette, Django, aiohttpCLI setup using the application's existing WSGI, ASGI, or aiohttp target.
    Java / JVMSpring MVC, Spring WebFlux, Quarkus, MicronautFramework setup. CLI installation covers Spring application classes and Quarkus Maven fast-JAR. Micronaut uses its dedicated SDK adapter; automatic CLI setup is pending. Spring Boot executable JARs are not covered.
    .NETASP.NET Core MVC, Minimal APIs, ASP.NET Core gRPCCLI setup with the checked .NET 10 build/start path. NativeAOT coverage is limited to the tested Minimal API configuration.
    Gonet/http, Chi, Gin, Echo, Fiber v2, grpc-goCLI setup and the generated build wrapper. Check the required toolchain and framework versions; Fiber v3 is not covered.
    PHPSlim, Laravel, Symfony, WordPressCLI setup and the framework's configured startup. FPM, Apache, and persistent-worker coverage remains incomplete.
    RubyRack, Sinatra, RailsCLI setup and the existing Rack server with the generated SDK preload. Rails controller/callback capture does not cover all ActiveRecord or ActiveJob activity.
    RustAxum, Actix Web, RocketCLI setup with the pinned rustc-dev toolchain and generated Cargo build/start wrapper.
    Elixir / ErlangPlug / Plug.Cowboy, PhoenixFramework setup. CLI installation covers a single Plug.Cowboy Mix app. Phoenix has a tested SDK adapter; automatic CLI installation/startup is pending.

    SSR application servers

    Next.js, Nuxt / Nitro, SvelteKit, Remix, React Router framework mode, Astro SSR, and Angular SSR have tested Node server integrations. For an application built and hosted by Claron, use Backend Evidence; the hosted build applies the server integration.

    For an SSR app on your own hosting, use its framework-specific SDK build/start integration and customer collector. The generic Node CLI installer does not configure every SSR framework. See SSR compatibility and the framework's setup path. Static output and browser-only routes have no server execution to capture.

    Get ready

    1. Choose the project

      Use the project owner's account. The project needs an active frontend environment, such as Staging, with the website URL you will review.

    2. Open the backend repository

      Work from the application's root directory. Install its normal dependencies and commit the version you will run. Keep its existing runtime and build tools available.

    3. Install the CLI

      Install the CLI and check the setup requirements for your framework.

    Setup in your terminal

    Node.js setup prompts with sample answers. Use your own project, environment and backend URL.

    Backend repository · setup prompts
    text
    $ claron backend init
    ? Connect to which Claron project? Storefront
    ? Which frontend environment will review this backend?
      Staging (https://staging.example.com)
    ? Backend service name checkout
    ? Backend public origin (comma-separated for multiple origins)
      https://api.example.com
    ? Enable the current experimental integration? Framework certification remains incomplete. Yes
    Connecting checkout to Staging; environment IDs are resolved automatically.
    ? Choose a recovery password (only needed for restoring access) ****************
    ? Confirm recovery password ****************

    Run one setup command

    1. Sign in and select the project

      Setup opens browser sign-in if needed. It reuses the repository's linked project or lets you choose an accessible project.

    2. Choose the environment

      Select the frontend environment you will review, such as Staging. Setup selects it automatically when only one is active.

    3. Name the backend and enter its URL

      Use a recognizable service name and the backend origin your website calls, such as https://api.example.com. Include the scheme and any port; leave out route paths such as /checkout. Confirm the experimental integration when prompted.

    4. Provide your framework's existing settings

      Setup detects the ecosystem and asks for required inputs, such as a Python application target or compiled Java classes. It installs the bundled JavaScript SDK where applicable and starts the local collector automatically.

    5. Save recovery access

      For a new enrollment, choose a recovery password of at least 16 characters. If this project already has diagnostic keys, provide its administrator backup and original password. Keep the generated recovery files and password somewhere safe.

    bash
    claron backend init

    Build and start your application

    1. Follow the printed framework instructions

      Node applications use the configured existing start command. Other ecosystems may require a generated build or startup wrapper. The framework guide explains each implemented path.

    2. Keep the collector available

      Setup has already started the customer-local collector. JavaScript's configured startup restores it automatically. For other ecosystems, use claron backend run -- followed by the generated application startup command to restore it on restart.

    3. Apply the setup on the host that runs your backend

      A successful setup on your laptop does not configure a different server. Keep the required runtime, configuration, and collector available on your backend's own host. Rebuild and restart after changing instrumentation.

    Check that it works

    1. Check setup health

      Run claron backend doctor and resolve any reported configuration or collector problem. Check Project → Settings → Backend for the expected service.

    2. Capture a new request

      Start a new review, use a page that calls your backend, and submit an annotation. Open Network evidence → the request → Backend evidence. Unlock it if needed.

    bash
    claron backend doctor

    If evidence is missing

    CheckWhat to do
    StartupConfirm the deployed backend uses the generated startup configuration, then restart it.
    CollectorCheck that it is running and reachable at the configured URL. Run doctor again.
    TargetCheck the selected frontend environment and exact backend origin used by the browser request.
    Locked evidenceUse the correct recovery file and its original password on an authorized device.
    Old reportStart a new review. Setup cannot recover requests that were never captured.