Dashello API

Push any data into your Dashello dashboard - numbers, tasks, events, or complex objects. Every connected app is inbound-only. Dashello never pushes your data outward.

Authentication

Every request requires an API key sent as a Bearer token in the Authorization header. You generate API keys from your Dashello Settings page.

Each API key is tied to your workspace. Data pushed with this key goes to your dashboard. Keys can be generated and revoked at any time from Settings → API Keys.

How to authenticate

# Include your API key in the Authorization header
curl https://dashello.co/api/ingest/metric \
  -X POST \
  -H "Authorization: Bearer dash_abc123..." \
  -H "Content-Type: application/json" \
  -d '{ "metric": "revenue", "value": 12345 }'

Key format

All API keys start with dash_ followed by a unique string. You can create named keys for each integration and revoke them individually.

Header format

Authorization: Bearer dash_your_api_key_here

Errors

The API returns standard HTTP status codes and a JSON error body:

Status	Error	Meaning
401	`invalid_api_key`	API key not found, revoked, or expired
400	`invalid_payload`	Missing required fields
404	`mapping_not_found`	No metric matched the incoming data
429	`rate_limited`	Too many requests. See rate limits below
500	`internal_error`	Something went wrong on our end

# Example error response
{
  "error": "invalid_api_key",
  "message": "API key not found or revoked"
}

POST /ingest/metric

POSThttps://dashello.co/api/ingest/metric

Push a single numerical value into a specific metric on your dashboard. This is the most common endpoint - use it for revenue, leads, costs, or any single number.

Request body

Field	Type	Description
metric	string required	Name of the metric (matched by label, ID, or source connector mapping)
value	number required	The numerical value to record
source	string optional	Source app identifier (e.g. "quickbooks", "stripe")
timestamp	string optional	ISO 8601 timestamp. Defaults to now
metadata	object optional	Additional context stored with the data point

curl https://dashello.co/api/ingest/metric \
  -X POST \
  -H "Authorization: Bearer dash_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "metric": "revenue",
    "value": 123456.78,
    "source": "quickbooks",
    "timestamp": "2026-05-20T12:00:00Z",
    "metadata": { "currency": "USD" }
  }'

Response - success

{
  "ok": true,
  "metric_id": "m_abc123",
  "previous_value": "$119,000.00",
  "new_value": "$123,456.78"
}

Response - no matching metric (inboxed)

{
  "ok": true,
  "inboxed": true,
  "message": "No metric matched 'revenue'. Data stored in inbox for mapping."
}

No matching metric? If your metric name doesn't match any existing box on your dashboard, the data is stored in your Inbox. You can browse the Inbox from the app's detail page and assign it to a metric box later.

POST /ingest/batch

POSThttps://dashello.co/api/ingest/batch

Push multiple metric values in a single request. Use this for efficiency when sending multiple data points at once.

Field	Type	Description
metrics	array required	Array of metric objects (see ingest/metric for each item's fields)
source	string optional	Default source label for all metrics in the batch

curl https://dashello.co/api/ingest/batch \
  -X POST \
  -H "Authorization: Bearer dash_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "metrics": [
      { "metric": "revenue", "value": 50000, "source": "quickbooks" },
      { "metric": "expenses", "value": 32000, "source": "quickbooks" },
      { "metric": "profit", "value": 18000, "source": "quickbooks" }
    ]
  }'

{
  "ok": true,
  "results": [
    { "metric": "revenue", "status": "updated" },
    { "metric": "expenses", "status": "updated" },
    { "metric": "profit", "status": "inboxed", "message": "No matching metric found" }
  ]
}

POST /ingest/data

POSThttps://dashello.co/api/ingest/data

Push any JSON data into Dashello. Unlike /ingest/metric, this endpoint accepts arbitrary objects, text, or complex data. If you have defined source connector mappings, the data will be automatically distributed to the right metric boxes. Otherwise, it goes to your inbox for manual assignment.

curl https://dashello.co/api/ingest/data \
  -X POST \
  -H "Authorization: Bearer dash_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "source": "quickbooks",
    "data_type": "invoice",
    "invoice_id": "INV-1042",
    "customer": "Acme Corp",
    "total": 12500.00,
    "status": "paid",
    "due_date": "2026-06-01"
  }'

How mapping works: If you've configured a source connector for "quickbooks" with a mapping like {"sourceField": "total", "metricId": "m_revenue"}, the total field will automatically update your revenue metric box. Everything else goes to your inbox.

POST /ingest/tasks

POSThttps://dashello.co/api/ingest/tasks

Push tasks directly into your Dashello Tasks page. This is useful for importing tasks from project management tools like Asana, Trello, or Jira.

curl https://dashello.co/api/ingest/tasks \
  -X POST \
  -H "Authorization: Bearer dash_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "source": "asana",
    "tasks": [
      { "text": "Review Q2 budget", "dueDate": "2026-06-15", "priority": true },
      { "text": "Update team on project status", "notes": "Include timeline changes" }
    ]
  }'

{
  "ok": true,
  "created": 2,
  "total": 17
}

Webhooks

Dashello can receive native webhooks from popular apps. Instead of polling or manually pushing data, you set up a webhook URL in the third-party app's settings, and Dashello receives events in real-time.

App	Webhook URL
QuickBooks	`https://dashello.co/api/webhook/quickbooks?connector_id=xxx`
Stripe	`https://dashello.co/api/webhook/stripe?connector_id=xxx`
HubSpot	`https://dashello.co/api/webhook/hubspot?connector_id=xxx`
Generic	`https://dashello.co/api/webhook/generic?connector_id=xxx`

When you create a source connector in Dashello and map its fields to your metric boxes, the webhook endpoint automatically distributes incoming data. Without a connector, data goes to your inbox.

QuickBooks Integration

Connect QuickBooks to automatically sync your accounting data - revenue, expenses, invoices, and profit - directly into your Dashello dashboard.

1 Create a source connector - In Dashello Settings → Integrations, click "Add New App" and select QuickBooks. Give it a name and save.

2 Map your fields - Tell Dashello which QuickBooks fields go to which metric boxes. For example: "TotalIncome" → "Monthly Revenue", "TotalExpenses" → "Operating Costs".

3 Set up the webhook - In QuickBooks, go to Settings → Webhooks and enter: https://dashello.co/api/webhook/quickbooks?connector_id=your_connector_id

4 Done - QuickBooks will now push data to Dashello automatically. You'll see it update in real-time on your dashboard.

Alternatively, use the direct API approach:

curl https://dashello.co/api/ingest/metric \
  -X POST \
  -H "Authorization: Bearer dash_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "metric": "Total Income",
    "value": 85000,
    "source": "quickbooks"
  }'

Stripe Integration

Connect Stripe to track payments, subscriptions, charges, and revenue metrics without any manual entry.

Event	Metric
`invoice.paid`	Invoice Paid (amount)
`invoice.payment_failed`	Payment Failed (1)
`charge.succeeded`	Charge Amount
`customer.subscription.created`	Subscription Amount
`customer.subscription.deleted`	Subscription Cancelled (1)

Set up the Stripe webhook endpoint in your Stripe Dashboard → Developers → Webhooks:

https://dashello.co/api/webhook/stripe?connector_id=your_connector_id

HubSpot Integration

Sync CRM activity - new contacts, deals, meetings, and pipeline changes - to your Dashello dashboard.

Event	Metric
`contact.creation`	New Contact (1)
`deal.creation`	New Deal (1)
`deal.propertyChange (amount)`	Deal Amount
`engagement.creation`	New Engagement (1)

Set up the HubSpot webhook:

https://dashello.co/api/webhook/hubspot?connector_id=your_connector_id

Zapier / Make Integration

Use Zapier or Make (formerly Integromat) to connect Dashello with thousands of apps. There's no Dashello-specific Zap yet, but you can use the Webhooks by Zapier or HTTP module in Make.

Zapier

1 Create a Zap - Choose your trigger app (e.g. Gmail, Typeform, Google Sheets).

2 Add "Webhooks by Zapier" action - Select "POST" as the action event.

3 Configure - URL: https://dashello.co/api/ingest/metric - Method: POST - Headers: Authorization: Bearer dash_your_api_key - Data: JSON body with metric and value.

4 Test & publish - Run a test and turn on your Zap.

Make (Integromat)

Use the HTTP module → "Make a request" with the same configuration as above.

URL: https://dashello.co/api/ingest/metric
Method: POST
Headers:
  Authorization: Bearer dash_your_api_key
  Content-Type: application/json
Body:
{
  "metric": "your_metric_name",
  "value": 12345,
  "source": "make"
}

Rate Limits

Limit	Value	Scope
Requests per minute	100	Per API key
Batch size	100 items	Per batch request
Payload size	5 MB	Per request

Need higher limits? Contact us at hello@dashello.co.

SDK Examples

No SDK is required - just HTTP. But here are ready-to-use snippets for common languages:

Node.js

const API_KEY = "dash_your_api_key";

async function pushMetric(name, value, source) {
  const res = await fetch("https://dashello.co/api/ingest/metric", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ metric: name, value, source }),
  });
  return res.json();
}

// Usage
await pushMetric("revenue", 50000, "quickbooks");

Python

import requests

API_KEY = "dash_your_api_key"

def push_metric(name, value, source="api"):
    res = requests.post(
        "https://dashello.co/api/ingest/metric",
        json={"metric": name, "value": value, "source": source},
        headers={"Authorization": f"Bearer {API_KEY}"}
    )
    return res.json()

# Usage
result = push_metric("leads", 47, "hubspot")
print(result)

Google Apps Script

function pushToDashello(metric, value) {
  const API_KEY = "dash_your_api_key";
  const options = {
    method: "post",
    headers: { "Authorization": "Bearer " + API_KEY },
    contentType: "application/json",
    payload: JSON.stringify({ metric, value, source: "google-sheets" }),
  };
  UrlFetchApp.fetch("https://dashello.co/api/ingest/metric", options);
}

// Use in a sheet trigger
function onEdit(e) {
  pushToDashello("Sheet Updated", 1);
}

Need help integrating? We're happy to walk through it with you.

Contact - hello@dashello.co