canonical: https://jentic.com/apis/eyepop.ai/eyepop

# EyePop WebAPI

Jentic publishes the only available OpenAPI specification for EyePop WebAPI, keeping it validated and agent-ready. The EyePop WebAPI is the control plane for the EyePop computer-vision platform, letting customers manage Pops (vision pipelines), upload inputs, attach models, run inference, and administer accounts, API keys and resource pools. Authentication is by Auth0 OAuth 2.0 implicit flow for interactive users or by JWT bearer tokens issued through the API-key endpoints for server-side workloads.

## For AI agents

Create and run EyePop computer-vision Pops, manage models and inputs, and administer accounts, API keys and resource pools through 104 endpoints under api.eyepop.ai.

## Scope

Does not handle text generation, audio transcription, or training of new vision models - use for orchestrating EyePop computer-vision pipelines and account administration only.

## Capabilities

- Create, configure and run vision Pops via /api/v1/user/pops to execute computer-vision pipelines
- Attach models to a Pop with POST /api/v1/user/pops/{id}/models to compose multi-stage inference
- Reserve and manage compute resources through /api/v1/resources/reserve and the admin resource endpoints
- Issue, list and revoke API keys for server-side access via /api/v1/api-keys
- Manage user accounts and team membership through /api/v1/accounts and /api/v1/accounts/{account_uuid}/users
- Inspect user credits, plans and usage with /api/v1/user/credits and /api/v1/user/me

## Use cases

### Build and Run a Vision Pipeline

Create an EyePop Pop, attach the required models, and run inference against uploaded inputs through a single REST surface. Pops are the orchestration unit for EyePop's vision pipelines and expose endpoints for start, stop, recreate, copy, and configuration retrieval. Iteration is fast because Pop edits and model attachments propagate without redeploying client code.

Example prompt: POST /api/v1/user/pops to create a Pop, POST /api/v1/user/pops/{id}/models to attach a detection model, then GET /api/v1/user/pops/{id}/start to run inference.

### Server-Side Integration via API Keys

Provision long-lived API keys for backend services that need to call EyePop without going through Auth0. The /api/v1/api-keys endpoints create, list, update and delete keys, and the resulting JWT bearer tokens are accepted by all user-facing operations on the API. This is the recommended path for cron jobs and webhook handlers that ingest media at scale.

Example prompt: POST /api/v1/api-keys to issue a key, store the resulting JWT in the secret manager, and use it as the Bearer token on subsequent calls to /api/v1/user/pops/{id}/start.

### Account and Resource Administration

Administer EyePop accounts, members, and reserved compute pools through the admin and account endpoints. Account owners can list, create, update and delete accounts, manage team membership at /api/v1/accounts/{account_uuid}/users/{user_uuid}, reserve resources at /api/v1/resources/admin/resource/reserve, and inspect resource pools and usage. Useful for platform engineers operating EyePop at organisational scale.

Example prompt: POST /api/v1/accounts to create the account, POST /api/v1/accounts/{account_uuid}/users/{user_uuid} to add a teammate, then POST /api/v1/resources/admin/resource/reserve to lock a GPU for the account's workload.

### Agent-Driven Vision Workflows via Jentic

An AI agent that needs computer vision can use Jentic to discover EyePop Pop operations, attach models, and run inference without hand-coding the client. The agent searches by intent, loads the operation schema, and the API key or Auth0 token stays inside your Jentic One instance rather than being exposed in the model context.

Example prompt: Through Jentic, search 'run an EyePop computer-vision pipeline', load POST /api/v1/user/pops and the start operation, then execute them with the configured model id.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | /api/v1/user/pops | Create a new Pop |
| GET | /api/v1/user/pops/{id}/start | Start a Pop |
| GET | /api/v1/user/pops/{id}/stop | Stop a Pop |
| POST | /api/v1/user/pops/{id}/models | Attach a model to a Pop |
| POST | /api/v1/api-keys | Issue a new API key |
| GET | /api/v1/user/credits | Get the current user's credit balance |
| POST | /api/v1/accounts | Create an EyePop account |
| POST | /api/v1/resources/admin/resource/reserve | Reserve compute resource |

## Key resources

- **Pops** — Create, configure, run, copy and delete vision pipelines
- **Pop inputs** — Manage media inputs that feed into a Pop
- **Models** — Attach and discover computer-vision models
- **Resources** — Reserve, list and administer compute resources and resource pools
- **API keys** — Issue and manage server-side API keys
- **Accounts and users** — Manage accounts, members and namespace prefixes

## Why Jentic

- **Setup:** Wiring the EyePop WebAPI by hand means running the Auth0 OAuth 2.0 flow, minting an EyePop JWT bearer token from /api/v1/api-keys, and targeting api.eyepop.ai across a 104-endpoint surface yourself. Through Jentic you install once, import the EyePop WebAPI from the API Directory, store the credential once, and your agent calls it.
- **Permission scoping:** EyePop puts the Pop id in the URL path (/api/v1/user/pops/{id}/...), so a rule can pin your agent to one Pop: it can start, stop, and attach models for that Pop and nothing else. You choose the operations it may call, so account-level actions like creating accounts or minting API keys are not included unless you add them.
- **Credential handling:** Your EyePop Auth0 credential and JWT bearer token are stored once, encrypted, by your own Jentic One instance and a scoped token is injected at execution time. The long-lived secret never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create an EyePop Pop' or 'start a vision pipeline', and Jentic returns the matching operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Exude API Service** — Lightweight English text preprocessing - useful when EyePop pipelines emit captions or transcripts that need cleanup.
- **Eyefinity Optometry EHR FHIR API** — Healthcare FHIR reads - pair with EyePop when building optometry-imaging workflows that combine vision inference and clinical context.

## FAQ

### Why is there no official OpenAPI spec for EyePop WebAPI?

EyePop does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call EyePop WebAPI 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 EyePop WebAPI use?

The spec declares two security schemes: an Auth0 OAuth 2.0 implicit flow at https://auth0.eyepop.ai/authorize for interactive users, and HTTP Bearer JWT tokens for server-side calls. Tokens are stored in your Jentic One instance and injected at execution time so they never appear in the agent prompt.

### Can I run object detection through the EyePop WebAPI?

Yes. Create a Pop with POST /api/v1/user/pops, attach a vision model with POST /api/v1/user/pops/{id}/models, and start the pipeline with GET /api/v1/user/pops/{id}/start to run inference on the configured inputs.

### How do I issue a server-side API key?

Call POST /api/v1/api-keys to create a key, then list and revoke keys via GET /api/v1/api-keys and DELETE /api/v1/api-keys/{id}; the issued JWT is the Bearer token used for headless calls.

### How do I run a Pop through Jentic?

Run pip install jentic, search 'run an EyePop computer-vision pipeline', load the POST /api/v1/user/pops and start operations, then execute them with the configured model id; Jentic injects the bearer token from the vault.

### What are the rate limits for the EyePop WebAPI?

The spec does not enumerate hard rate limits, so honour 429 responses with exponential backoff and check your account credit balance via GET /api/v1/user/credits before launching large batch runs.

### Can I limit what my agent is allowed to do with the EyePop WebAPI?

Yes. Because you self-host Jentic One, your own rules decide which EyePop operations and credentials the agent may use. Since the Pop id sits in the URL path (/api/v1/user/pops/{id}/...), a rule can pin the agent to a single Pop so it can only start, stop, and attach models for that Pop with POST /api/v1/user/pops/{id}/models. Account-level actions such as creating accounts via POST /api/v1/accounts or minting keys via POST /api/v1/api-keys stay off limits unless you explicitly grant them.