> ## Documentation Index
> Fetch the complete documentation index at: https://docs.stairoids.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Quickstart: Get Started with Stairoids in 10 Minutes
> Follow these steps to send your first signal, view it in the dashboard, and wire up an integration — all end-to-end in under 10 minutes.
This guide walks you through everything you need to get a signal flowing through Stairoids from end to end. By the time you finish, you'll have sent a real signal via the API, seen it appear in your dashboard with a computed engagement score, and connected your first integration so that signals start arriving automatically. No dummy data, no skipped steps — just a working setup you can build on.
All API requests are made to the base URL **`https://api.stairoids.com/v1`**. Every request must include an `Authorization: Bearer ` header.
Sign in to your Stairoids workspace at [app.stairoids.com](https://app.stairoids.com). Once you're in, navigate to **Settings → API Keys** and click **Generate New Key**.
Give the key a descriptive name (for example, `quickstart-test`) and copy it somewhere safe — Stairoids only shows the full key once. You'll use this key to authenticate every API request you make.
Treat your API key like a password. Never commit it to source control or expose it in client-side code. If a key is compromised, revoke it immediately from the **Settings → API Keys** page and generate a replacement.
With your API key in hand, send a `POST` request to the `/v1/signals` endpoint. The example below represents a contact named Jane visiting your pricing page — a classic intent signal.
```bash cURL theme={null}
curl --request POST \
--url https://api.stairoids.com/v1/signals \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"type": "page_visit",
"account": {
"domain": "acme.com"
},
"contact": {
"email": "jane@acme.com"
},
"properties": {
"page": "/pricing"
}
}'
```
```python Python theme={null}
import requests
url = "https://api.stairoids.com/v1/signals"
headers = {
"Authorization": "Bearer YOUR_API_KEY",
"Content-Type": "application/json"
}
payload = {
"type": "page_visit",
"account": {"domain": "acme.com"},
"contact": {"email": "jane@acme.com"},
"properties": {"page": "/pricing"}
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())
```
```javascript Node.js theme={null}
const response = await fetch("https://api.stairoids.com/v1/signals", {
method: "POST",
headers: {
"Authorization": "Bearer YOUR_API_KEY",
"Content-Type": "application/json"
},
body: JSON.stringify({
type: "page_visit",
account: { domain: "acme.com" },
contact: { email: "jane@acme.com" },
properties: { page: "/pricing" }
})
});
const signal = await response.json();
console.log(signal);
```
A successful request returns `201 Created` with the full signal object, including its generated ID and computed engagement score:
```json Response theme={null}
{
"id": "sig_01hx9k2mz4e7vb3qw8n6cf5r0d",
"type": "page_visit",
"account": {
"id": "acc_07btp1nyz9s3lk6ew2mx4rh8qa",
"domain": "acme.com",
"name": "Acme Corp",
"score": 42
},
"contact": {
"id": "con_03wzq8fyj1r5ug7xt4se6pk2mv",
"email": "jane@acme.com",
"score": 38
},
"properties": {
"page": "/pricing"
},
"score": 15,
"created_at": "2024-11-14T09:32:07.421Z"
}
```
The `score` field on the signal itself reflects the weight Stairoids assigns to this signal type. The `account.score` and `contact.score` fields are the running cumulative engagement scores for those entities, updated in real time. See [Core Concepts](/core-concepts) for a full explanation of how scoring works.
Head back to [app.stairoids.com](https://app.stairoids.com) and open the **Signals** tab in the left navigation. You'll see the `page_visit` signal you just sent listed at the top of the feed, tagged with the account domain `acme.com` and the contact email `jane@acme.com`.
Click the signal row to open the detail view. From here you can:
* Inspect all signal properties and metadata.
* Navigate to the **Account** or **Contact** profile to see their full engagement timeline and score history.
* Manually trigger any outgoing automation that references this signal type.
Sending signals via the API is powerful, but most teams want signals flowing in automatically from their existing tools. Stairoids has native integrations with HubSpot, HeyReach, Leadfeeder, Pipedrive, and more.
To connect your first integration:
1. Go to **Settings → Integrations** in your workspace.
2. Choose the tool you want to connect.
3. Follow the OAuth or API key flow for that integration.
4. Map which events from that tool should become signals in Stairoids.
Once connected, signals from that tool start appearing in your feed automatically — no additional API calls required.
For a full list of available integrations and setup guides, see the [Integrations Overview](/integrations/overview).
Now that signals are flowing in, tell Stairoids what to do with them. Outgoing Automations are rules that fire when a signal or score condition is met and push an action to one of your connected tools.
For example, you can create an automation that enrolls a contact in a HeyReach outreach sequence every time they visit `/pricing`. To build this:
1. Go to **Automations → Outgoing** in your workspace.
2. Click **New Automation**.
3. Set the trigger to **Signal Type → `page_visit`** with a property filter of `page = /pricing`.
4. Set the action to **HeyReach → Enroll Contact in Sequence** and choose your target sequence.
5. Save and enable the automation.
From this point on, every qualifying `page_visit` signal will automatically trigger the enrollment — no manual intervention needed.
For a deep dive into automation logic, conditions, and available actions, see [Outgoing Automations](/signals/outgoing-automations).
## What's next
You've sent a signal, seen it scored, and wired up your first automation. Here's where to go from here:
Deepen your understanding of how Signals, Intelligence, and Automations fit together.
Explore every native integration and learn how to configure event mappings.
Build powerful, multi-condition automation rules that act on your signals.
Browse the full REST API reference for signals, accounts, contacts, and more.