Skip to content
anecticoDocs
Dashboard
Browse documentation
Guide

Quickstart: see your first customer story

Connect one application, identify a test customer, and follow an error across their Anectico timeline.

Read as Markdown ↗Use with an LLM ↗
On this page

This quickstart proves the part of Anectico that matters: signals from one application become one connected story for the customer they affected.

You will send a test error and a trace (server SDKs) or diagnostic event (mobile SDKs), attach them to a customer, and inspect the result in the dashboard. Allow about ten minutes once your app and SDK artifact are available.

Start with your agent

Open Get started (/get-started) in the dashboard. New accounts land here automatically. Choose Claude Code, Codex, another CLI agent, or manual setup, then select your application stack. The guide supplies connection commands and a project-specific task for your agent to install the SDK, identify a test customer, send a controlled error, and verify the stored evidence. Your own agent can investigate through MCP or the CLI on any Anectico plan; hosted Customer Detective is optional and requires Scale.

Run the copied connection block in a POSIX-compatible terminal. It clears an older agent key from that shell and stops at the first failed step. Resolve the reported error and run the block again; the agent starts only after login, credential setup, and host registration succeed.

Your choices and test identifiers are saved to the selected project when you continue, so an administrator can resume on another device. Read-only members can follow the guide without saving shared progress. Keys are shown once and are never stored in the setup draft. Verification always reads live data; returning to a saved step does not imply that instrumentation is healthy. The trace ID is saved before verification, even if the evidence check temporarily fails.

For a workflow entirely from your terminal, see Run an agent without the dashboard. If you have not received your early-access SDK artifact or CLI access, contact support.

Before you start

You need:

  • access to an Anectico organization;
  • a project in Settings → Projects; and
  • a project-scoped API key with ingest:write and analytics:write in Settings → Access.

This example needs both scopes: traces and errors use ingest:write, while Identify uses the diagnostic capture surface protected by analytics:write. Choose Application when creating the key, or create it in Get started. The Ingest only preset does not include identity capture. The Browser + replay preset also grants replay:write; add replay after the basic test works.

Keep the application credential separate from your agent's ANECTICO_API_KEY. For server examples, keep the application key in an environment variable. Do not put it in source code. For mobile, inject the same project-scoped write-only key through your app's development configuration and pass it to the helper below. Keys shipped in client apps are visible to their users; never substitute a read, management, or agent credential.

export ANECTICO_INGEST_KEY="an_..."

1. Install an SDK

Choose the language used by your service or existing mobile app. During early access, use the package artifact or repository access supplied during onboarding. The JavaScript and Python examples below install local artifacts so the commands work before the public registries open.

JavaScript / TypeScript

mkdir anectico-quickstart && cd anectico-quickstart
npm init -y
npm install /path/to/anectico-sdk.tgz

Python

mkdir anectico-quickstart && cd anectico-quickstart
python -m venv .venv
source .venv/bin/activate
pip install /path/to/anectico.whl

Go

mkdir anectico-quickstart && cd anectico-quickstart
go mod init example.com/anectico-quickstart
go get github.com/anectico/anectico/sdks/go@main

Swift (iOS)

In your existing iOS app, add the authorized Anectico repository in Xcode's File → Add Package Dependencies…, select the onboarding revision, and link the Anectico product. See the iOS install guide.

Kotlin (Android)

Copy the supplied AAR to your app module's libs/anectico-sdk.aar and add this dependency:

dependencies {
    implementation(files("libs/anectico-sdk.aar"))
}

React Native

From your existing React Native app:

npm install /path/to/anectico-react-native.tgz
cd ios && pod install

Flutter

In your existing app's pubspec.yaml, use your authorized checkout:

dependencies:
  anectico_flutter:
    path: /path/to/anectico/sdks/flutter

Run flutter pub get. For iOS also run flutter config --enable-swift-package-manager and use an iOS deployment target of at least 15.

For browser instrumentation or more platform details, see Choose an integration.

2. Start Anectico and identify a customer

JavaScript / TypeScript

import { initNode } from '@anectico/sdk/node';
import { AnalyticsClient } from '@anectico/sdk/analytics';

const apiKey = process.env.ANECTICO_INGEST_KEY;
if (!apiKey) throw new Error('ANECTICO_INGEST_KEY is required');

const anectico = await initNode({
  apiKey,
  serviceName: 'quickstart',
  environment: 'development',
});
const events = new AnalyticsClient({
  endpoint: 'https://api.anectico.com',
  apiKey,
});

events.identify('quickstart-user', {
  email: 'quickstart@example.com',
  plan: 'test',
});

anectico.tracer.startActiveSpan('checkout', span => {
  try {
    anectico.captureError(new Error('quickstart payment failure'));
  } finally {
    span.end();
  }
});

await events.stop();
await anectico.stop();

Save this as quickstart.mjs.

Python

import os
import anectico

with anectico.AnecticoClient(
    api_key=os.environ['ANECTICO_INGEST_KEY'],
    service_name='quickstart',
    environment='development',
) as client:
    client.identify('quickstart-user', {
        'email': 'quickstart@example.com',
        'plan': 'test',
    })
    with client.start_span('checkout'):
        client.capture_error(RuntimeError('quickstart payment failure'))

Save this as quickstart.py.

Go

package main

import (
	"context"
	"errors"
	"os"

	anectico "github.com/anectico/anectico/sdks/go"
)

func main() {
	ctx := context.Background()
	client, err := anectico.New(
		anectico.WithAPIKey(os.Getenv("ANECTICO_INGEST_KEY")),
		anectico.WithServiceName("quickstart"),
		anectico.WithEnvironment("development"),
	)
	if err != nil {
		panic(err)
	}

	if err := client.Start(ctx); err != nil {
		panic(err)
	}
	defer client.Stop(ctx)

	if err := client.Identify(ctx, "quickstart-user", map[string]any{
		"email": "quickstart@example.com",
		"plan":  "test",
	}); err != nil {
		panic(err)
	}

	traceCtx, span := client.StartSpan(ctx, "checkout")
	client.CaptureError(traceCtx, errors.New("quickstart payment failure"))
	span.End()
}

Save this as main.go.

Swift (iOS)

Add this development-only helper to your app and call it once with your project key. If the SDK is already configured, keep that setup and use only the identity, capture, and flush calls.

import Foundation
import Anectico

func sendQuickstart(apiKey: String) throws {
    try Anectico.configure(AnecticoOptions(apiKey: apiKey, environment: "development"))
    Anectico.identify("quickstart-user", set: ["email": "quickstart@example.com", "plan": "test"])
    Anectico.capture("checkout_started")
    Anectico.captureError(NSError(
        domain: "Quickstart", code: 1,
        userInfo: [NSLocalizedDescriptionKey: "quickstart payment failure"]
    ))
    Anectico.flush { accepted in
        print("Diagnostic events accepted: \(accepted)")
    }
}

Kotlin (Android)

Call this helper once from your initialized application's development flow. If you already call Anectico.init at startup, omit the duplicate initialization here.

import android.content.Context
import com.anectico.sdk.Anectico
import com.anectico.sdk.AnecticoOptions

fun sendQuickstart(context: Context, apiKey: String) {
    Anectico.init(context, AnecticoOptions(apiKey = apiKey, environment = "development"))
    Anectico.identify("quickstart-user", set = mapOf("email" to "quickstart@example.com", "plan" to "test"))
    Anectico.capture("checkout_started")
    Anectico.captureError(IllegalStateException("quickstart payment failure"))
    Anectico.flush()
}

React Native

Add this helper to your app. Call it once in a development flow, passing your project key; skip configure here if your app already configures the SDK.

import * as Anectico from '@anectico/react-native';

async function sendQuickstart(apiKey: string) {
  await Anectico.configure({ apiKey, environment: 'development' });
  await Anectico.identify('quickstart-user', { email: 'quickstart@example.com', plan: 'test' });
  await Anectico.capture('checkout_started');
  await Anectico.captureError(new Error('quickstart payment failure'));
  const accepted = await Anectico.flush();
  console.log('Diagnostic events accepted:', accepted);
}

Flutter

Call this helper from your development startup after WidgetsFlutterBinding.ensureInitialized() or from a test button. Skip configure if your app already initializes the plugin.

import 'package:anectico_flutter/anectico_flutter.dart';

Future<void> sendQuickstart(String apiKey) async {
  await Anectico.configure(AnecticoOptions(apiKey: apiKey, environment: 'development'));
  await Anectico.identify('quickstart-user', set: {'email': 'quickstart@example.com', 'plan': 'test'});
  await Anectico.capture('checkout_started');
  await Anectico.captureError(StateError('quickstart payment failure'), StackTrace.current);
  final accepted = await Anectico.flush();
  print('Diagnostic events accepted: $accepted');
}

Run the program once:

JavaScript / TypeScript

node quickstart.mjs

Python

python quickstart.py

Go

go run .

Swift (iOS)

Build and run your app in Xcode on a simulator or device, then invoke try sendQuickstart(apiKey: ...) once from your development flow. Handle any thrown configuration error.

Kotlin (Android)

Build and run your app in Android Studio on an emulator or device, then call sendQuickstart(applicationContext, ...) once with your development project key.

React Native

Rebuild and run the native iOS or Android app using your project's run command, then call await sendQuickstart(...) once. A JavaScript reload alone cannot install the SDK's native module.

Flutter

Run flutter run on an iOS or Android target and call await sendQuickstart(...) once. The mobile plugin is not supported on Flutter web or desktop.

Keep a mobile app running while its asynchronous error transport sends. Mobile flush reports diagnostic-event delivery, not error/span delivery; do not immediately terminate the process.

3. Open the customer story

In Anectico:

  1. Select the same project and the development environment.
  2. Open Customers.
  3. Search for quickstart@example.com or quickstart-user.
  4. Open the customer.

The activity timeline should contain your test error plus the checkout trace (server examples) or checkout_started event (mobile examples). Open the error to see its Issue, then return to the customer. Mobile SDKs do not automatically record full network traces; to add a backend trace, follow Mobile SDK propagation.

4. Ask Anectico what happened

Select Explain this person on the customer page, or open Investigate and ask:

What happened to quickstart@example.com?

Anectico gathers matching evidence and links each claim back to the underlying signal.

If nothing appears

Most setup failures are an API key, project, environment, or shutdown/flush mismatch. Follow No data is appearing before changing sampling or transport settings.

Next