# Quickstart: see your first customer story

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

Canonical page: https://anectico.com/docs/start/quickstart/


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](/docs/agents/zero-dashboard-quickstart).
If you have not received your early-access SDK artifact or CLI access, [contact support](/docs/help/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.

```bash
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.

<div data-language-tabs="quickstart-install" data-language-tabs-label="Choose an SDK"></div>

**JavaScript / TypeScript**

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

**Python**

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

**Go**

```bash
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](/docs/instrument/ios#install-with-swift-package-manager).

**Kotlin (Android)**

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

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

**React Native**

From your existing React Native app:

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

**Flutter**

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

```yaml
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.

<div data-language-tabs-end="quickstart-install"></div>

For browser instrumentation or more platform details, see [Choose an integration](/docs/start/choose-integration).

## 2. Start Anectico and identify a customer

<div data-language-tabs="quickstart-code" data-language-tabs-label="Choose an SDK"></div>

**JavaScript / TypeScript**

```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**

```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**

```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.

```swift
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.

```kotlin
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.

```typescript
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.

```dart
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');
}
```

<div data-language-tabs-end="quickstart-code"></div>

Run the program once:

<div data-language-tabs="quickstart-run" data-language-tabs-label="Choose an SDK"></div>

**JavaScript / TypeScript**

```bash
node quickstart.mjs
```

**Python**

```bash
python quickstart.py
```

**Go**

```bash
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.

<div data-language-tabs-end="quickstart-run"></div>

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](/docs/instrument/mobile#connect-a-mobile-request-to-the-backend).

## 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](/docs/help/no-data) before changing sampling or transport settings.

## Next

- [How Anectico works](/docs/start/how-anectico-works)
- [Connect an agent without the dashboard](/docs/agents/zero-dashboard-quickstart)
- [Read the docs as Markdown or through MCP](/docs/reference/machine-readable-docs)

- [Identify customers correctly](/docs/instrument/identity)
- [Capture errors and releases](/docs/instrument/errors)
- [Understand a customer story](/docs/investigate/customer-story)