> ## Documentation Index
> Fetch the complete documentation index at: https://lifters.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Developer Quickstart

> Send your first event to Atlas in under 5 minutes.

## Prerequisites

* An Atlas account — [sign up at app.atlas.io](https://app.atlas.io)
* An API key for your brand — [Dashboard → Settings → API Keys](https://app.atlas.io/settings/api)

## Step 1 — Get Your API Key

After creating your account and brand, navigate to **Settings → API Keys** and copy your key. It looks like:

```
atl_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
```

<Warning>
  Keep your API key secret. Never expose it in client-side code or public repositories.
  Use environment variables in production.
</Warning>

## Step 2 — Send Your First Event

Let's track a sports bet placement. Replace `YOUR_API_KEY`, `YOUR_ORG_ID`, and `YOUR_BRAND_ID` with your values:

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://events.atlas.io/api/v1/sport \
    -H "X-API-Key: YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "org_id": "YOUR_ORG_ID",
      "brand_id": "YOUR_BRAND_ID",
      "event": "open",
      "user_id": "user_12345",
      "currency": "BRL",
      "bet_id": "bet_abc_001",
      "bet_dt": "2026-03-11T14:30:00Z",
      "ticket_status": "open",
      "bet_amount": 50.00,
      "bet_odds": 2.90,
      "bet_type": "SINGLE",
      "bet_timing": "PREMATCH",
      "bet_platform": "MOBILE",
      "bet_virtual": false,
      "selections": [
        {
          "selection_id": "sel_001",
          "selection_status": "open",
          "selection_sport_type": "Soccer",
          "selection_market": "Match Winner",
          "selection_odds": 2.90
        }
      ]
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://events.atlas.io/api/v1/sport', {
    method: 'POST',
    headers: {
      'X-API-Key': 'YOUR_API_KEY',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      org_id: 'YOUR_ORG_ID',
      brand_id: 'YOUR_BRAND_ID',
      event: 'open',
      user_id: 'user_12345',
      currency: 'BRL',
      bet_id: 'bet_abc_001',
      bet_dt: new Date().toISOString(),
      ticket_status: 'open',
      bet_amount: 50.00,
      bet_odds: 2.90,
      bet_type: 'SINGLE',
      bet_timing: 'PREMATCH',
      bet_platform: 'MOBILE',
      bet_virtual: false,
      selections: [
        {
          selection_id: 'sel_001',
          selection_status: 'open',
          selection_sport_type: 'Soccer',
          selection_market: 'Match Winner',
          selection_odds: 2.90,
        },
      ],
    }),
  });

  const result = await response.json();
  console.log(result); // { data: { bet_id: "bet_abc_001" } }
  ```

  ```go Go theme={null}
  package main

  import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "time"
  )

  type SportEvent struct {
    OrgID        string                   `json:"org_id"`
    BrandID      string                   `json:"brand_id"`
    Event        string                   `json:"event"`
    UserID       string                   `json:"user_id"`
    Currency     string                   `json:"currency"`
    BetID        string                   `json:"bet_id"`
    BetDT        string                   `json:"bet_dt"`
    TicketStatus string                   `json:"ticket_status"`
    BetAmount    float64                  `json:"bet_amount"`
    BetOdds      float64                  `json:"bet_odds"`
    BetType      string                   `json:"bet_type"`
    BetTiming    string                   `json:"bet_timing"`
    BetPlatform  string                   `json:"bet_platform"`
    BetVirtual   bool                     `json:"bet_virtual"`
    Selections   []map[string]interface{} `json:"selections"`
  }

  func main() {
    event := SportEvent{
      OrgID:   "YOUR_ORG_ID",
      BrandID: "YOUR_BRAND_ID",
      Event:   "open",
      UserID:  "user_12345",
      Currency: "BRL",
      BetID:   "bet_abc_001",
      BetDT:   time.Now().UTC().Format(time.RFC3339),
      TicketStatus: "open",
      BetAmount: 50.00,
      BetOdds: 2.90,
      BetType: "SINGLE",
      BetTiming: "PREMATCH",
      BetPlatform: "MOBILE",
      BetVirtual: false,
      Selections: []map[string]interface{}{
        {
          "selection_id":         "sel_001",
          "selection_status":     "open",
          "selection_sport_type": "Soccer",
          "selection_market":     "Match Winner",
          "selection_odds":       2.90,
        },
      },
    }

    body, _ := json.Marshal(event)
    req, _ := http.NewRequest("POST", "https://events.atlas.io/api/v1/sport", bytes.NewBuffer(body))
    req.Header.Set("X-API-Key", "YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
      panic(err)
    }
    fmt.Printf("Status: %d\n", resp.StatusCode) // 202 Accepted
  }
  ```
</CodeGroup>

## Step 3 — Verify the Response

A successful response returns `202 Accepted`:

```json theme={null}
{
  "data": {
    "bet_id": "bet_abc_001"
  }
}
```

The event is now in the Atlas pipeline. It will appear in your dashboard within seconds.

## Step 4 — Check the Dashboard

Go to [app.atlas.io](https://app.atlas.io) → **Events** to see your event in real-time.

## Next Steps

<CardGroup cols={2}>
  <Card title="Track Users" icon="user" href="/guides/events/tracking-users">
    Register and update player profiles
  </Card>

  <Card title="Track Transactions" icon="money-bill" href="/guides/events/tracking-transactions">
    Deposits, withdrawals, and payment events
  </Card>

  <Card title="Track Casino" icon="dice" href="/guides/events/tracking-casino">
    Casino bet tracking with round data
  </Card>

  <Card title="Batch Ingestion" icon="layer-group" href="/guides/events/batch-ingestion">
    Send hundreds of events in a single call
  </Card>
</CardGroup>