canonical: https://jentic.com/apis/loadster.com/loadster

# Loadster API

The Loadster API works with the same projects, scripts, scenarios, datasets, monitors, and load test results as the Loadster dashboard. It lets you build and import test scripts (including JMeter, k6, or Locust scripts), play a script once on an engine, launch a load test from a scenario's trigger code, follow its status, and read the finished test report and advice. The monitoring side manages synthetic monitors, their cycles and status periods, incidents, notification policies, and maintenance windows, and you can register self-hosted engines alongside Loadster's cloud regions.

## For AI agents

Launch Loadster load tests from a trigger code, check status and read test reports and advice, edit projects, scripts, scenarios, and datasets, and manage synthetic monitors, incidents, and maintenance windows.

## Scope

Does not host or deploy your application, collect production APM traces, or manage on-call schedules. Use for load testing, script authoring, and synthetic monitoring in Loadster only.

## Capabilities

- Launch a load test from a scenario's trigger code with startTestRunByShortcut and an optional label, then poll its status by test code
- Read a finished load test's report and the advice Loadster generates for it with getTestReportData and getTestAdvice
- Stop a running cloud load test gracefully with stopCloudTest or immediately with killCloudTest
- Import a JMeter, k6, or Locust script into a Loadster script with importScript
- Play a script once on an engine with playScript and read the run and its assets, such as screenshots
- Create synthetic monitors with frequency and response-time thresholds, then read their cycles, status periods, and incidents
- Schedule maintenance windows and notification policies that apply to a set of monitors

## Use cases

### Agent-run load tests through Jentic

A coding agent finishing a performance change asks Jentic for the Loadster operation that launches a test, calls startTestRunByShortcut with the scenario's trigger code, then polls getTestStatusByShortcut and reads getTestReportDataByShortcut once the run finishes. The personal access token used for project and monitor operations stays in your self-hosted Jentic One instance.

Example prompt: Search Jentic for 'launch a Loadster load test', call startTestRunByShortcut with the scenario shortcut and label 'release-42', then poll getTestStatusByShortcut until it finishes and summarize the report

### Load test review and advice

After a test, an agent calls getTestReportData for the project and test ids to read response times, errors, and hit counts, then getTestAdvice for Loadster's own guidance on the finished test. Notes can be written back to the report with updateTestReportData.

Example prompt: Call getTestReportData for projectId 'p1' and testId 't9', then call getTestAdvice for the matching cloud test id and list the top issues

### Migrating scripts from other tools

Teams moving to Loadster call importScript on a target script with source set to the original JMeter, k6, or Locust script, optionally replacing existing steps and setting a baseUrl. duplicateScript copies a working script into another project for reuse.

Example prompt: Call importScript for projectId 'p1' and scriptId 's3' with the k6 script as source and replace true

### Synthetic monitoring and incidents

Create a monitor with createMonitor pointing at a repository project and script, set its frequency and acceptable response-time ranges, and attach notification policies. getIncidents and getMonitorPeriods show when it failed, and maintenance windows stop alerts during planned deploys.

Example prompt: Call getIncidents with includeResolved false, then call getMonitorPeriods for each affected monitor id over the last day

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/s/{shortcut}` | Launch a load test from a trigger code |
| GET | `/t/{shortcut}/status` | Get a load test's status by test code |
| GET | `/projects/{projectId}/tests/{testId}/report` | Get a load test report |
| GET | `/cloud/tests/{id}/advice` | Get advice on a finished load test |
| POST | `/projects/{projectId}/scripts/{scriptId}/actions/import` | Import a JMeter, k6, or Locust script |
| POST | `/player/script/actions/start` | Play a script once |
| POST | `/monitoring/monitors` | Create a monitor |
| GET | `/monitoring/incidents` | List incidents |

## Key resources

- **Projects** — Containers for scripts, scenarios, datasets, and load tests
- **Scripts** — Test steps with revisions and assets, importable from JMeter, k6, or Locust
- **Load tests** — Running and finished tests with status, reports, and advice
- **Monitors** — Synthetic monitors with cycles, status periods, and incidents
- **Engines** — Cloud regions and registered self-hosted engines

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 59 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 80 / 100
  - Developer Experience & Jentic Compatibility: 56 / 100
  - AI-Readiness & Agent Experience: 41 / 100
  - Agent Usability: 88 / 100
  - Security: 60 / 100
  - AI Discoverability: 60 / 100
- **View full report:** https://jentic.com/apis/loadster.com/loadster/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring Loadster by hand means knowing which calls take the personal access token and which trigger-code endpoints need none, then polling test status and fetching reports yourself. Through Jentic you install once, import Loadster from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** Loadster puts projectId in the URL path for scripts, scenarios, datasets, tests, and runs, so a rule can pin your agent to one project: it can work under `/projects/{projectId}`/ for that project and nothing else. You choose the operations it may call, so destructive ones like deleteProject or killCloudTest are not included unless you add them.
- **Credential handling:** Your Loadster personal access token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'launch a load test' or 'list monitoring incidents', and Jentic returns the matching Loadster operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **BlazeMeter API** — Cloud load testing built around JMeter and other open-source tools
- **Loader.io API** — Simple cloud load testing for web apps and APIs
- **Checkly API** — Synthetic API and browser checks with alerting
- **Better Stack API** — Uptime monitoring, incident management, and status pages

## FAQ

### What authentication does the Loadster API use?

Per its OpenAPI spec, the Loadster API uses an HTTP bearer scheme carrying a personal access token from the Loadster dashboard, sent as `Authorization: Bearer`. The trigger-code endpoints under /s/ and /t/ need no token, because the code in the path authorizes the request. Through Jentic the token is stored encrypted by your own Jentic One instance and injected at call time.

### Can I start a load test from CI with the Loadster API?

Yes. POST `/s/{shortcut}` launches a load test from a scenario's trigger code, with an optional label query parameter. Then poll GET `/t/{shortcut}/status` with the returned test code and read GET `/t/{shortcut}/report` or download GET `/t/{shortcut}/report.json` when it finishes.

### What are the rate limits for the Loadster API?

The OpenAPI spec does not specify rate limits. Check the Loadster documentation for current limits, and poll test status at a modest interval rather than in a tight loop.

### How do I read a load test report with the Loadster API through Jentic?

Install Jentic One with `curl -fsSL https://raw.githubusercontent.com/jentic/jentic-one/main/tools/install.sh | sh`, add the Loadster API from the Jentic API Directory, and have your agent search for 'get a load test report'. Jentic returns getTestReportData (GET `/projects/{projectId}/tests/{testId}/report`) with its schema, and the agent passes the project and test ids. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Is there a Loadster MCP server?

Yes - Loadster offers an MCP server for AI assistants. You can also connect the Loadster API directly through Jentic: your agent gets the full 85-endpoint surface from the spec without loading another server's tool definitions into its context, your credential is injected at call time by your self-hosted instance instead of living in an MCP config, and your rules decide which operations the agent may call.

### Can I limit what my agent is allowed to do with the Loadster API?

Yes. Write a rule that allows GET under `/projects/p1`/ plus the trigger and status calls for your checkout scenario. The agent can then launch that test and read its reports in one project, while deleteProject, deleteMonitorById, and killCloudTest are outside the allowed set, and every call it makes is logged.

### Can the Loadster API import scripts from JMeter, k6, or Locust?

Yes. POST `/projects/{projectId}/scripts/{scriptId}/actions/import` takes a required source query parameter with the original script, plus optional replace and baseUrl parameters, and converts it into the target Loadster script.