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

# Jumppl External API

Jentic publishes the only available OpenAPI specification for Jumppl External API, keeping it validated and agent-ready. Jumppl is a team productivity platform that combines task and project management with chat, calendar, and time-tracking. The external API exposes endpoints to create projects and tasks, manage subtasks, copy or move tasks across projects, and bridge external systems like Shopify and GitHub by ingesting them as Jumppl tasks. It also includes business-account lookups and message pulling for chat-based agent integrations.

## For AI agents

Create and move tasks, spin up projects, and route Shopify, GitHub, or chat events into Jumppl as actionable work items.

## Scope

Does not handle CRM contact management, billing, or HR records - use for project, task, and chat-driven productivity automation only.

## Capabilities

- Create projects from saved templates and seed initial task structures with POST `/api/v1/task/CreateNewProject`
- Create, copy, and move tasks across projects with CreateNewTask, CopyTasks, and MoveTasks operations
- Spawn subtasks under existing tasks for granular execution tracking
- Ingest Shopify orders and GitHub issues directly as Jumppl tasks via dedicated bridge endpoints
- Auto-assign tasks based on configured automation rules through `/api/automation/TaskAssign`
- Pull chat messages and business profile data for use in agent reasoning loops

## Use cases

### Shopify-To-Task Fulfilment Bridge

An e-commerce team wants every new Shopify order to land as a Jumppl task assigned to the warehouse pod. POST `/api/v1/task/CreateShopifyTasks` accepts the Shopify payload and creates a Jumppl task with the order metadata, while automation rules assign it to the on-shift packer. This removes the spreadsheet-based handoff that typically delays first-pick by 30-60 minutes.

Example prompt: When a Shopify order webhook fires, call POST `/api/v1/task/CreateShopifyTasks` with the order ID and SKU list, then call `/api/automation/TaskAssign` to route it to the warehouse team.

### GitHub Issue Mirroring for PMs

Project managers want non-engineering visibility into GitHub work without giving everyone GitHub seats. POST `/api/v1/task/CreateGitHubTasks` ingests an issue or PR as a Jumppl task with the title, body, and labels preserved. The team's PM dashboard then shows engineering work alongside ops and design tasks in one pipeline.

Example prompt: For repository 'acme/web', call POST `/api/v1/task/CreateGitHubTasks` with the GitHub issue payload to create a Jumppl task in the 'Engineering' project.

### Project Cloning for Repeatable Workflows

Operations teams frequently launch the same multi-step playbook (client onboarding, event prep, audits). Using GET `/api/v1/task/GetMySavedProjectTemplate` to fetch a template and POST `/api/v1/task/CreateNewProject` to instantiate it, the team spins up a fully-structured project in seconds. CopyTasks and MoveTasks then let the lead reorganise without rebuilding.

Example prompt: List saved templates via GET `/api/v1/task/GetMySavedProjectTemplate`, then call POST `/api/v1/task/CreateNewProject` with template ID 'tpl-onboarding' and client name 'Acme Corp'.

### Agent-Triaged Inbound Work

An AI assistant monitoring the team's chat and email can route inbound asks into Jumppl as tasks via Jentic. The agent picks the right project, creates a task with POST `/api/v1/task/CreateNewTask`, then calls TaskAssign to assign it. This replaces ad-hoc Slack pings with tracked, owned work items.

Example prompt: Through Jentic, search 'create a task', load CreateNewTask schema, and execute with project 'support', title 'Refund request from customer 1234', and assignee 'on-call'.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/v1/task/CreateNewProject` | Create a new project, optionally from a template |
| POST | `/api/v1/task/CreateNewTask` | Create a new task in a project |
| POST | `/api/v1/task/CreateNewSubTask` | Create a subtask under an existing task |
| POST | `/api/v1/task/MoveTasks` | Move tasks between projects |
| POST | `/api/v1/task/CreateShopifyTasks` | Ingest a Shopify order as a task |
| POST | `/api/v1/task/CreateGitHubTasks` | Ingest a GitHub issue or PR as a task |
| POST | `/api/automation/TaskAssign` | Auto-assign a task based on configured rules |
| GET | `/api/v1/task/GetAllTasks` | List tasks across the workspace |

## Key resources

- **Tasks** — Create, copy, move, and list tasks plus subtasks across projects
- **Projects** — List projects and create new projects from saved templates
- **Automation** — Auto-assign tasks based on rule configuration
- **Bridges** — Ingest Shopify orders and GitHub issues as Jumppl tasks; pull chat messages
- **Business** — Retrieve business and account profile information

## Why Jentic

- **Setup:** Wiring the Jumppl External API by hand means learning its API key auth and shaping the request payloads for its task, project, and automation operations yourself. Through Jentic you install once, import the Jumppl External API from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Jumppl names each operation in the path (for example `/api/v1/task/CreateNewTask`) and identifies targets in the request body, so you limit the agent to the operations it needs, such as creating a task or moving tasks. Operations like creating a new project are left out unless you include them.
- **Credential handling:** Your Jumppl 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 task' or 'move tasks between projects', and Jentic returns the matching Jumppl operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Asana API** — Mature project and task management API with broader ecosystem coverage than Jumppl.
- **ClickUp API** — Task and project platform with deep custom-field and automation support.
- **GitHub API** — Pair GitHub issues with Jumppl tasks for cross-functional visibility.
- **Shopify Admin API** — Source Shopify orders that Jumppl turns into operational tasks.

## FAQ

### Why is there no official OpenAPI spec for Jumppl External API?

Jumppl does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Jumppl External API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Jumppl External API use?

The Jumppl External API uses an API key auth scheme. The key is sent on each request and identifies the calling business account. Through Jentic the API key sits in the encrypted vault, so the agent runtime never sees the raw value.

### Can I create tasks from Shopify orders with the Jumppl External API?

Yes. POST `/api/v1/task/CreateShopifyTasks` ingests a Shopify payload and creates a corresponding Jumppl task, which can then be auto-assigned through `/api/automation/TaskAssign.`

### What are the rate limits for the Jumppl External API?

Jumppl applies per-account rate limits that vary by plan; the spec does not enumerate fixed values. Treat 429 responses with exponential backoff and batch task creations where possible.

### How do I create a new project with the Jumppl External API through Jentic?

Search Jentic for 'create a new project', load POST `/api/v1/task/CreateNewProject`, and execute with the project name and template ID. Jentic handles auth and returns the new project's ID.

### Can I move tasks between projects in bulk?

Yes. POST `/api/v1/task/MoveTasks` accepts a list of task IDs and a target project, and POST `/api/v1/task/CopyTasks` does the same for copy semantics, preserving the original tasks in place.

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

Yes. Because you run Jentic One yourself, your own rules decide which Jumppl operations and credentials the agent may use. Since Jumppl names each operation in the path, such as `/api/v1/task/CreateNewTask` or `/api/v1/task/MoveTasks`, and identifies the target project or task in the request body, you can allow only the operations the agent needs, like creating or moving tasks, while leaving out others such as `/api/v1/task/CreateNewProject.` The Jumppl API key stays with your self-hosted instance and is only injected into the operations you have permitted.