# Quick Start

> Connect an application with a coding agent or manual setup.

Telemetry Machine gives you two ways to connect an application. Both start on the same onboarding screen.

- [With a coding agent](https://telemetrymachine.com/docs/quick-start#option-1-set-up-with-a-coding-agent) The agent instruments your application, creates the required datasets and API keys, and verifies that data arrives.
- [Manual setup](https://telemetrymachine.com/docs/quick-start#option-2-set-up-manually) Create the datasets and API keys yourself, then use the generated OpenTelemetry configuration.

## Create your account

1. [Sign up](https://telemetrymachine.com/register) with your email address and a password.
1. Verify your email address. In the browser you signed up in, that signs you in.
1. Open an explorer such as **Traces**. If your organization has no datasets, Telemetry Machine takes you to onboarding.

## Option 1: Set up with a coding agent

Use this path when a coding agent can edit your application and run commands in its development environment. On the onboarding page, pick your agent in the first step.

### Claude Code

1. In a terminal, install the Telemetry Machine plugin. It needs Claude Code 2.1.292 or later. The plugin adds the Telemetry Machine MCP server.

   ```console
   $ claude plugin install telemetry-machine --marketplace telemetry-machine/agent-skills
   ```

1. Start Claude Code in your application's folder, run `/mcp`, choose `plugin:telemetry-machine:telemetry-machine`, and sign in.
1. Start onboarding:

   ```text
   /mcp__plugin_telemetry-machine_telemetry-machine__onboarding
   ```

1. Answer its questions. Claude Code instruments your application, creates the datasets and API keys it needs, confirms that data arrives, and answers a first question from your data.

If you stop part-way, run the same command again. It continues from where you stopped.

### Other coding agents

1. Add `https://telemetrymachine.com/api/mcp` to your agent as a remote MCP server (Streamable HTTP). The onboarding page shows the exact command or configuration for Codex and Cursor.
1. Sign in when your agent asks. It opens your browser; approve there.
1. In your application's folder, ask your agent:

   ```text
   Use the telemetry-machine MCP server: call get_onboarding_guide and follow it to set up this app.
   ```

> [!NOTE]
> Keep the onboarding page open to follow progress. It shows when your agent has signed in and lists the datasets it creates. Select one to open its explorer.

## Option 2: Set up manually

1. Open [Create a dataset](https://telemetrymachine.com/datasets/new).
1. Choose the data you want to send: traces, logs, metrics, or events.
1. Name the dataset and choose any optional starter widgets.
1. Create the dataset. Telemetry Machine also creates a starter API key for it.
1. Copy the API key and store it securely.

   > [!CAUTION]
   > Its full value is only shown once.

1. Choose the generated setup for the OpenTelemetry Collector, Node.js, or Python. An events dataset gets a `curl` command instead.
1. Add the configuration to your application and run or deploy it.
1. Open the matching explorer and confirm that your data arrives.

A dataset holds one type of data, so the generated setup sends only that type. For a traces dataset it looks like this, with your API key and dataset name filled in:

<!-- prettier-ignore -->
```yaml title="otel-collector.yaml" tab="Collector" {5-6}
exporters:
  otlp_http:
    endpoint: "https://api.telemetrymachine.com"
    headers:
      X-API-Key: "<your-api-key>"
      X-Dataset-Name: "<your-dataset>"

service:
  pipelines:
    traces:
      exporters: [otlp_http]
```

<!-- prettier-ignore -->
```js title="instrumentation.mjs" tab="Node.js" {9-10}
// npm install @opentelemetry/sdk-node @opentelemetry/exporter-trace-otlp-http
import { NodeSDK } from '@opentelemetry/sdk-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: 'https://api.telemetrymachine.com/v1/traces',
    headers: {
      'X-API-Key': '<your-api-key>',
      'X-Dataset-Name': '<your-dataset>',
    },
  }),
  // NodeSDK would otherwise export these too.
  metricReaders: [],
  logRecordProcessors: [],
});

sdk.start();
```

<!-- prettier-ignore -->
```python title="instrumentation.py" tab="Python" {12-13}
# pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

provider = TracerProvider()

exporter = OTLPSpanExporter(
    endpoint="https://api.telemetrymachine.com/v1/traces",
    headers={
        "X-API-Key": "<your-api-key>",
        "X-Dataset-Name": "<your-dataset>",
    },
)

provider.add_span_processor(BatchSpanProcessor(exporter))
trace.set_tracer_provider(provider)
```

Collector versions before v0.144.0 call the exporter `otlphttp`.

You can repeat the manual wizard to create more datasets for other signal types, services, or environments.

## tm-cli

`tm-cli` is Telemetry Machine's command line, for terminals and CI. Download the build for your OS and architecture from the [release manifest](https://telemetrymachine.com/downloads/tm-cli/manifest.json), check its sha256, and put `tm-cli` on your `PATH`. Then sign in in your browser:

```bash
tm-cli auth login
```

In CI, set `TM_API_KEY` to a personal access token instead.

---

All pages: https://telemetrymachine.com/docs/llms.txt
