Introduction

Travo Documentation

Travo is an independent API health monitoring platform for developers. It continuously monitors popular developer APIs — measuring latency, error rates, and uptime — and notifies you when something breaks.

Unlike vendor status pages, Travo runs its own synthetic checks from the outside, giving you an objective view of whether an API is actually reachable and performing well from your users' perspective.

69+ APIs monitored

Across 14 categories including AI, payments, cloud, and more

Checked every minute

Staggered synthetic checks around the clock

Instant alerts

Email, webhook, and HookTap push notifications

Getting Started

Getting Started

You don't need to install anything. Travo runs entirely in the browser.

1

Create a free account

Go to app.gettravo.com and sign up with your email. No credit card required for the free tier.

2

View the API Status dashboard

After logging in, you'll see the Services page — a live overview of all 69+ monitored APIs with their current status, latency, and uptime.

3

Set up your Stack

Go to My Stack and select the APIs your project depends on. You can either pick them manually or auto-detect them from a GitHub repository.

4

Configure alerts (optional)

Navigate to Alerts to enable email, webhook, or HookTap notifications when your stack has an incident.

Dashboard

Dashboard

The main dashboard gives you a summary of the current state across all monitored APIs.

Total / Operational / Degraded / DownFour stat cards at the top show you at a glance how many APIs are currently healthy or experiencing issues.
Status BannerA green or yellow banner summarises whether all monitored services are operational or if there are active incidents.
Recent IncidentsA feed of the latest detected incidents across all APIs, with links to the individual service detail pages.
My StackA live preview of the APIs in your personal stack, showing current latency and status for each.
Services

Services Page

The Services page shows all 69+ monitored APIs with real-time status, latency, and 24h uptime.

SearchFilter APIs by name using the search box.
Status filterShow only Operational, Degraded, or Down APIs.
Category filterFilter by category: AI, Payments, Cloud, DevTools, Database, Auth, Communication, Search, Monitoring, Analytics, Media, Maps, Productivity, or Commerce.
Auto-refreshData is polled every 30 seconds so status changes appear without a page reload.

Service detail page

Clicking any API card opens a detail page showing:

Uptime summary24h and 7-day uptime percentages.
90-day uptime barA daily uptime visualization for the last 90 days.
Latency chartAverage latency over the last 24 hours in 5-minute buckets.
Error rate chartError rate percentage over the last 24 hours.
Incident historyAll detected incidents for this API with severity, type, and duration.
My Stack

My Stack

My Stack lets you create a personal monitoring view of only the APIs your project depends on. This makes it easy to quickly diagnose whether a problem is in your own code or caused by an external service.

Stack nameGive your stack a name to identify it — e.g. the name of your project or app. It's auto-filled when you detect from a GitHub repository.
Manual selectionBrowse all available APIs and check the ones you use.
Auto-detectionConnect GitHub and Travo automatically detects which APIs are used in your repository — see the Auto Stack Detection section.
Stack status bannerAt the top of My Stack you'll see a banner showing whether all your stack services are healthy or if any are experiencing issues.
Auto Stack Detection

Automatic Stack Detection

Travo can analyze your GitHub repository and automatically identify which monitored APIs your project depends on.

How to use it

1

Go to My Stack → Edit Stack

Click the Edit Stack button on your stack page.

2

Connect GitHub or paste a URL

If you signed in with GitHub, a dropdown shows your repositories directly — including private ones. Otherwise paste any public GitHub repository URL, e.g. https://github.com/yourname/yourrepo

3

Detect dependencies

Click Detect from GitHub. Travo analyzes your dependency files and pre-selects matching APIs. The stack name is auto-filled from the repository name.

Private repositories are supported when you sign in with GitHub and grant repository access during the OAuth flow. You can choose between public-only or public + private access at login.

Supported dependency files

package.json

Node.js / npm

requirements.txt

Python (pip)

Pipfile

Python (Pipenv)

go.mod

Go modules

Gemfile

Ruby

composer.json

PHP

Incidents

Incidents

Travo automatically detects incidents based on the data collected during synthetic checks. No manual reporting is needed.

Incident types

Downtime — CriticalTriggered when the last 3 consecutive checks all failed. Resolved automatically when checks start succeeding again.
High Error Rate — Warning / CriticalTriggered when the failure rate over the last 10 checks exceeds 20%. Severity is Critical above 50%.
Latency Spike — WarningTriggered when the average latency of the last 5 successful checks exceeds the API-specific threshold.

Incident lifecycle

Incidents are opened automatically when conditions are detected and closed automatically when the situation normalises. You can view active and historical incidents on the Incidents page or in the detail page of each individual API.

Alerts

Alerts & Notifications

Configure notification channels in the Alerts page. Alerts are sent when a new incident is detected for any API.

Notification channelsThree channels are available: Email, Webhook, and HookTap. Each can be enabled or disabled independently.
Notification type filtersFor each channel you can choose which event types trigger a notification: Downtime, High Error Rate, Latency Spike, and Resolved. This lets you reduce noise — e.g. only get paged for critical downtime, not latency warnings.
EmailEnter your email address and enable email notifications. Emails are sent from notifications@mail.gettravo.com.
WebhookProvide an HTTP endpoint URL. Travo will POST a JSON payload when an incident is detected or resolved. See the Webhook Integration section.
HookTapEnter your HookTap Hook ID to receive instant iPhone push notifications. See the HookTap Integration section.
Test alertsUse the Send test buttons on the Alerts page to verify each channel is working before a real incident occurs.
Integration

HookTap Integration

HookTap is an iOS app that receives webhooks and turns them into instant iPhone push notifications, lock screen widgets, and Live Activities — with no account required.

1

Install HookTap

Download HookTap from the App Store on your iPhone.

2

Get your Hook ID

Open the app and copy your personal Hook ID from the settings screen.

3

Add it to Travo

Go to Alerts in Travo, enable HookTap, and paste your Hook ID.

Payload sent to HookTap

POST https://hooks.hooktap.me/webhook/<YOUR_HOOK_ID>

{
  "type": "push",
  "title": "🔴 Stripe",
  "body": "Stripe is down: last 3 consecutive checks failed."
}
Integration

Webhook Integration

Travo can POST to any HTTP endpoint when an incident is detected. Use this to connect to n8n, Zapier, Make, Slack, PagerDuty, or your own backend.

Payload format

POST <your-webhook-url>
Content-Type: application/json

{
  "type": "incident",
  "api": "openai",
  "severity": "critical",
  "incidentType": "downtime",
  "message": "OpenAI is down: last 3 consecutive checks failed.",
  "startedAt": "2024-06-01T14:32:00.000Z"
}

Field reference

FieldTypeDescription
typestring"incident" or "resolved"
apistringAPI slug, e.g. "stripe", "openai"
severitystring"critical" or "warning"
incidentTypestring"downtime", "error_rate", or "latency"
messagestringHuman-readable description of the incident
resolvedbooleantrue when this notification is a resolution event
startedAtstringISO 8601 timestamp when the incident was detected
Developer

Status API

Travo exposes a read-only HTTP API that returns live monitoring data. No authentication is required for the public endpoints.

GET/api-routes/status

Returns all monitored APIs with their latest metric, active incident, and 24h uptime.

[
  {
    "id": "clx...",
    "name": "Stripe",
    "slug": "stripe",
    "category": "Payments",
    "latestMetric": {
      "latencyMs": 142,
      "statusCode": 200,
      "success": true,
      "timestamp": "2024-06-01T14:30:00.000Z"
    },
    "activeIncident": null,
    "uptime24h": 99.93
  },
  ...
]
GET/api-routes/metrics/:slug

Returns raw metrics for a specific API over the last 24 hours.

{
  "api": { "id": "...", "name": "Stripe", "slug": "stripe" },
  "metrics": [
    {
      "id": "...",
      "latencyMs": 138,
      "statusCode": 200,
      "success": true,
      "timestamp": "2024-06-01T14:25:00.000Z"
    },
    ...
  ]
}
GET/api-routes/incidents/:slug

Returns the last 20 incidents for a specific API.

[
  {
    "id": "...",
    "type": "downtime",
    "severity": "critical",
    "message": "Stripe is down: last 3 consecutive checks failed.",
    "startedAt": "2024-06-01T14:00:00.000Z",
    "resolvedAt": "2024-06-01T14:12:00.000Z"
  },
  ...
]

Base URL: https://app.gettravo.com

Code examples

JavaScript / TypeScript

const res = await fetch('https://app.gettravo.com/api-routes/status')
const apis = await res.json()

const stripe = apis.find(a => a.slug === 'stripe')
console.log(stripe.latestMetric.latencyMs) // e.g. 142
console.log(stripe.uptime24h)              // e.g. 99.93
console.log(stripe.activeIncident)         // null or { severity, type }

Python

import requests

res = requests.get('https://app.gettravo.com/api-routes/status')
apis = res.json()

stripe = next(a for a in apis if a['slug'] == 'stripe')
print(stripe['latestMetric']['latencyMs'])
print(stripe['uptime24h'])
print(stripe['activeIncident'])

cURL

curl https://app.gettravo.com/api-routes/status
curl https://app.gettravo.com/api-routes/metrics/stripe
curl https://app.gettravo.com/api-routes/incidents/openai

Build with AI

Copy a ready-made prompt and paste it into Claude, ChatGPT, or any AI assistant to instantly get integration code for your project.

Teams

Teams

Teams let you share a monitoring stack and alert configuration with colleagues. All team members see the same API status and receive the same notifications.

Create a teamGo to Team in the sidebar and click Create team. Give it a name and you'll become the team owner.
Invite membersFrom the Team page, enter a colleague's email address to send them an invite link. They can join via the link without needing to know your account details.
Join a teamOpen the invite link you received. If you don't have a Travo account yet, you'll be prompted to sign up first.
Leave a teamYou can leave a team at any time from the Team settings page.
Shared historyTeam plans retain 14 days of metric history, giving your team enough context to investigate recurring incidents.
FAQ

Frequently Asked Questions

Is Travo free to use?

Yes. The Starter plan is completely free and includes the live API status dashboard, basic history, and one personal stack. No credit card required.

Do I need to install anything?

No. Travo is entirely browser-based. You sign up, configure your stack, and monitoring starts immediately.

How often are APIs checked?

All APIs are checked once per minute, staggered across the 60-second window so checks are distributed evenly.

How long is data retained?

Raw metrics are retained for 14 days. This applies to all plans and gives teams enough history to investigate recurring incidents.

What APIs does Travo monitor?

Travo monitors 69+ APIs across 14 categories: Communication, Search, Analytics, AI, Auth, Cloud, Media, Payments, Database, Monitoring, DevTools, Productivity, Maps, Commerce. The list is continuously growing.

Can I monitor private GitHub repositories?

Yes. Sign in with GitHub and grant repository access during the OAuth flow. You can choose public-only or public + private access. Travo uses your GitHub token to read dependency files from private repos — it never stores your code.

How is this different from vendor status pages?

Vendor status pages are self-reported and often updated with delay or understate the severity of incidents. Travo runs independent synthetic checks from the outside, so you see what your users actually experience.