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

# LoopGantt API

The LoopGantt API turns a task list with durations and dependencies into a scheduled Gantt chart, computing the critical path, float, and project end date. A keyless endpoint creates a chart and returns a claim link the user can open to view, export, and save it, while a separate scheduling endpoint returns dates without storing anything. Dependencies support the FS, SS, FF, and SF link types with lag, tasks can be grouped under phases, and industry templates for software, construction, marketing, events, IT, HR, and finance provide ready-made task lists. Account holders can also create stored projects and list the projects they own with a bearer API key.

## For AI agents

Schedule a task plan with dependencies, get back the critical path and end date, and hand the user a LoopGantt claim link or PNG of the chart. Start from an industry template or create stored projects with an API key.

## Scope

Does not handle time tracking, team assignments, resource leveling, or budgets. Use for scheduling task plans into Gantt charts with critical-path dates only.

## Capabilities

- Compute a critical-path schedule with dates, float, and project end from a task list via POST /schedule without storing anything
- Create a Gantt chart without an account through POST /gantt and return the claimUrl the user opens to view, export, and save it
- Link tasks with FS, SS, FF, or SF dependencies and lag, and group them under phases using isPhase and parent
- Start a plan from industry templates such as software, construction, or events via GET /templates and GET `/templates/{slug}`
- Render the scheduled chart as a PNG with the critical path highlighted through GET `/gantt/{token}/image.png`
- Create stored projects with tasks and list the projects you own through POST /projects and GET /projects with an API key

## Use cases

### Agent-built project plans through Jentic

A planning agent turns a conversation about a launch into tasks with durations and dependencies, then calls LoopGantt through Jentic to schedule them and return a chart the user can open. The agent searches Jentic for 'create a Gantt chart', receives the POST /gantt input schema with its tasks, dependencies, and workDays fields, and hands the user the claimUrl from the response.

Example prompt: Search Jentic for 'create a Gantt chart', then call POST /gantt with name 'Website relaunch', startDate '2026-12-01', and tasks Design (10 days), Build (15 days, FS on Design), and Launch (milestone, FS on Build), and return the claimUrl to the user

### What-if schedule checks

Before committing to a plan, compute the schedule for alternative task orders or durations and compare the end dates. POST /schedule runs the critical-path engine and returns dates, the critical path, and float for each task without storing a chart, so a planner can test several variants and keep only the one that fits the deadline.

Example prompt: Call POST /schedule twice with the same five tasks, once with Testing at 5 days and once at 10 days, and report which variant finishes before 2027-02-01

### Template-based kickoff

Start a new plan from LoopGantt's industry templates instead of a blank page. GET /templates lists templates for software, construction, marketing, events, IT, HR, and finance with task counts and typical durations, and GET `/templates/{slug}` returns the task list with durations and milestones, ready to adjust and pass to POST /gantt.

Example prompt: Call GET /templates, pick the events template, fetch it with GET `/templates/{slug}`, shift the start date to 2027-03-01, and create the chart with POST /gantt

### Chart image for status updates

Drop a picture of the current plan into a status update or chat thread. GET `/gantt/{token}/image.png` returns a server-rendered PNG of the scheduled chart with the critical path highlighted and milestones drawn as diamonds, covering at most 40 rows, and fetching it does not extend the chart's expiry.

Example prompt: Take the token from the last segment of a claimUrl and call GET `/gantt/{token}/image.png`, then attach the PNG to the weekly status message

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/gantt` | Create a Gantt chart without an account |
| POST | `/schedule` | Compute a critical-path schedule without storing it |
| GET | `/gantt/{token}` | Read the chart behind a claim link |
| GET | `/gantt/{token}/image.png` | Render the chart as a PNG |
| GET | `/templates` | List industry templates |
| GET | `/templates/{slug}` | Get one template with its task list |
| POST | `/projects` | Create a stored project with tasks |
| GET | `/projects` | List your projects |

## Key resources

- **Gantt charts** — Keyless charts created from a task list, read back by the token in their claim link or rendered as a PNG
- **Schedules** — Critical-path results with dates, float, and project end, computed without storing anything
- **Templates** — Industry task lists with durations and milestones, ready to adapt into a chart
- **Projects** — Stored projects with tasks, owned by an authenticated LoopGantt account

## 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:** 62 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 59 / 100
  - Developer Experience & Jentic Compatibility: 64 / 100
  - AI-Readiness & Agent Experience: 47 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 77 / 100
- **View full report:** https://jentic.com/apis/loopgantt.com/loopgantt/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 LoopGantt by hand means modelling task dependencies with FS, SS, FF, and SF links, tracking which endpoints are keyless and which need the sk_live_ bearer key, and handling 429 responses with Retry-After. Through Jentic you install once, import LoopGantt from the API Directory, store the API key once, and your agent calls it.
- **Permission scoping:** Rules filter by method and path, so you can bound the agent to LoopGantt's keyless planning operations, such as scheduling and template reads, and leave the authenticated project operations out. Chart reads carry the claim token in the path (`/gantt/{token}`), so a rule can also pin the agent to one chart's read and image operations.
- **Credential handling:** Your LoopGantt API key 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 'create a Gantt chart' or 'compute a critical path', and Jentic returns the matching LoopGantt operation with its input schema, including the tasks and dependencies structure, so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Smartsheet API** — Work-management sheets with Gantt views, rows, and dependencies for teams that keep plans in Smartsheet
- **Asana API** — Task and project tracking with assignees, sections, and due dates
- **monday.com API** — Boards and items with timeline columns for team work management
- **Trello API** — Kanban boards and cards for day-to-day task execution

## FAQ

### What authentication does the LoopGantt API use?

Per its OpenAPI spec, the LoopGantt API uses a bearer token, an API key in the sk_live_ format, on the project endpoints POST /projects and GET /projects. The chart, schedule, and template endpoints such as POST /gantt and POST /schedule are keyless and need no credential. Through Jentic, the API key is stored encrypted by your own Jentic One instance and attached at execution time.

### Can I get the critical path without creating a chart?

Yes. POST /schedule takes the same task list as POST /gantt, with durations, dependencies of type FS, SS, FF, or SF, optional lag, workDays, and holidays, and returns dates, the critical path, float, and project end. Nothing is stored, so it suits trying several plan variants before creating the chart the user will keep.

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

The OpenAPI spec states that POST /gantt is limited to 10/hour and 30/day, and that POST /schedule is rate limited to 60 per hour per network. Exceeded limits return HTTP 429 with a Retry-After header. Check https://loopgantt.com for current limits on the authenticated project endpoints.

### How do I create a Gantt chart with LoopGantt through Jentic?

Install Jentic One, add the LoopGantt API from the Jentic directory, and have your agent search for 'create a Gantt chart'. Jentic returns the POST /gantt operation with its input schema; the agent sends name, startDate, and tasks, then gives the user the claimUrl from the response. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### How long does a keyless LoopGantt chart last?

A chart created with POST /gantt expires after 7 days, extended to 30 days once its claim link is opened. Reading it with GET `/gantt/{token}` extends the expiry, while fetching the PNG with GET `/gantt/{token}/image.png` does not. The user saves the chart to an account from the claim link to keep it.

### Is there a LoopGantt MCP server?

You don't need an MCP server to give your agent LoopGantt. Jentic connects it directly from the API Directory: import it, store your API key once for the project endpoints, and your agent calls it. Operations are found on demand by intent, so no extra tool definitions sit in the agent's context.

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

Yes. A rule that allows POST /schedule and GET /templates lets the agent plan and test schedules without creating anything, and adding POST /gantt lets it hand out new charts while your saved projects stay out of reach. The agent's calls are logged for review.