canonical: https://jentic.com/apis/go.v7labs.com/v7labs

# Go V7labs V7 Go API

Jentic publishes the only available OpenAPI specification for V7 Go API, keeping it validated and agent-ready. V7 Go is V7 Labs' AI workflow platform for processing unstructured documents into structured data using large language models. The API exposes workspaces, projects, properties, entities, files, hubs, skills, agent builders, MCP integrations, and case management - letting teams automate knowledge work like contract review, claims processing, and document extraction. It supports both API-key and bearer authentication and covers 274 endpoints for orchestrating AI agents, file uploads, tool integrations, and downstream reporting.

## For AI agents

Run V7 Go AI document workflows: upload files, define properties to extract, execute skills and agent builders, and read structured results. Designed for high-volume document automation.

## Scope

Does not handle image labelling for computer-vision training, dataset annotation, or model training - use for V7 Go document AI workflows only.

## Capabilities

- Upload and confirm file ingestion into a workspace project for AI extraction
- Define properties on a project so V7 Go knows what fields to extract from each document
- Execute agent-builder requests against entities to produce structured outputs
- Manage hubs and folders that organise files within a workspace
- Connect external tool and MCP integrations that V7 skills can call during a run
- Pull token usage and billing reports per project for cost monitoring

## Use cases

### Contract Review Automation

Upload signed contracts to V7 Go and define properties such as effective date, governing law, and termination clause. The platform runs an extraction skill against each document and returns structured field values that an agent can write into a contract management system. The API handles file upload confirmation, property definition, and entity-level result retrieval.

Example prompt: Upload contract.pdf to project 7700, define properties for effective_date and counterparty, and return the extracted entity values.

### Claims Processing Pipeline

Insurance teams stream claim documents through V7 Go to extract structured fields and route exceptions to human reviewers. The cases endpoint set lets an agent confirm tool runs, mark cases as read, and queue follow-up messages, so claim triage runs without manual document handling.

Example prompt: Process claim 4521 by uploading attachments, running the claims-extraction skill, and flagging missing fields back to the case timeline.

### Knowledge Base Ingestion

Bulk-ingest a folder of internal documents into a V7 Go hub, run an extraction skill across them, and surface entities for downstream search. Hubs and folders provide the organisational structure; properties drive what each skill extracts; and the entities endpoints expose the resulting structured rows.

Example prompt: Upload all PDFs from a hub folder into project 8800, run the summary-extraction skill, and list the resulting entities.

### AI Agent Tool Orchestration

An AI agent uses Jentic to drive V7 Go end-to-end: search for the right operation, load the schema, and chain calls (upload, run skill, read entities). Bearer tokens stay in your Jentic One instance, and the agent only ever sees the input/output schemas.

Example prompt: Search Jentic for 'extract data with v7 go', load the agent_builder execute schema, run it against case 9100, and return structured results.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/workspaces/{workspace_id}/files/confirm` | Confirm a completed file upload |
| POST | `/api/workspaces/{workspace_id}/agent_builder/{request_id}/execute` | Execute an agent builder request |
| POST | `/api/workspaces/{workspace_id}/projects/{project_id}/entities/filter` | Filter entities in a project |
| GET | `/api/workspaces/{workspace_id}/projects/{project_id}/billing/usage` | Get token usage for a project |
| GET | `/api/workspaces/{workspace_id}/folders/tree` | Read the folder tree for a workspace |
| POST | `/api/workspaces/{workspace_id}/cases/{case_id}/confirm_tool_run` | Confirm a tool run on a case |
| GET | `/api/workspaces/{workspace_id}/integrations/all/connections` | List integration connections |
| GET | `/api/workspaces/{workspace_id}/skills/{skill_id}/settings` | Read skill settings |

## Key resources

- **Workspaces** — Top-level container for projects, hubs, and integrations
- **Projects** — Define properties, entities, and skills for a document workflow
- **Files** — Upload and confirm files for ingestion into projects and hubs
- **Hubs** — Organise files into folders with member access controls
- **Skills** — Configurable AI extraction units that run against entities
- **Agent Builder** — Compose and execute multi-step agent requests
- **Cases** — Track per-document workflows including tool runs and queued messages
- **Integrations** — Connect external tools and MCP servers to skills
- **Reports** — Pull token usage and billing data per project

## Why Jentic

- **Setup:** Wiring the V7 Go API by hand means handling both its X-API-KEY header and bearer auth and mapping its 274-endpoint workspace surface yourself. Through Jentic you install once, import the V7 Go API from the API Directory, store the credential once, and your agent calls it.
- **Permission scoping:** V7 Go puts the workspace id in the URL path (`/api/workspaces/{workspace_id}/...`), so a rule can pin your agent to one workspace: it can run document AI operations there and nothing else. You choose the operations it may call, so it confirms files or executes builders only when you include those operations.
- **Credential handling:** Your V7 Go API key or bearer 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 'extract data with V7 Go' or 'filter project entities', and Jentic returns the matching V7 operation with its input schema so the agent calls the right endpoint without browsing 274 paths.

## Related APIs

- **GO1 API** — GO1 delivers the underlying learning content that some V7 knowledge-work pipelines reference.
- **OpenAI API** — OpenAI offers raw LLM extraction without V7's document workflow and entity model.
- **GitHub REST API** — Trigger V7 Go runs from GitHub events such as a new file in a release artifact.

## FAQ

### Why is there no official OpenAPI spec for V7 Go API?

V7 Labs does not publish an OpenAPI specification for the V7 Go product. Jentic generates and maintains this spec so AI agents and developers can call V7 Go 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 V7 Go API use?

V7 Go supports two schemes: an API key sent via the X-API-KEY header, and HTTP bearer tokens. Through Jentic, both credential types are stored encrypted and injected at execution time so the agent never sees the raw secret.

### Can I run an agent builder execution with the V7 Go API?

Yes. POST `/api/workspaces/{workspace_id}/agent_builder/{request_id}/execute` runs a configured agent builder request and returns the execution result. Pair it with the case endpoints to track tool runs and queued follow-up messages.

### What are the rate limits for the V7 Go API?

The OpenAPI spec does not declare numeric rate limits. V7 Labs publishes plan-tier limits in its product documentation; in practice, batch file uploads and back off on HTTP 429 responses.

### How do I extract structured data from a document through Jentic?

Run a Jentic search for 'extract data with v7 go', load the schema for the file upload and skill execution endpoints, then call them in sequence. Install with pip install jentic and use the async search, load, and execute pattern.

### Does the V7 Go API support MCP integrations?

Yes. The `/api/workspaces/{workspace_id}/mcp-integrations` endpoints let you list and configure MCP servers that V7 skills can call as tools during an agent run.

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

Yes. Because you run Jentic One yourself, your own rules decide which V7 Go operations and credentials the agent may use. Since V7 Go carries the workspace id in every path (`/api/workspaces/{workspace_id}/...`), a rule can pin the agent to a single workspace and nothing else. You also choose the specific operations it may call, so it can confirm file uploads, execute agent builder requests, or filter project entities only when you include those operations.