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

# Prioritysoftware Priority REST API

Jentic publishes the only available OpenAPI specification for Priority REST API, keeping it validated and agent-ready. Priority REST API provides OData-based access to Priority ERP for reading, querying, creating, updating, and deleting business entities across all Priority forms. The API exposes 13 endpoints covering entity CRUD, subform navigation, batch operations with up to 100 operations per request, and metadata management including cache clearing. It supports Basic authentication and Bearer token (PAT) access.

## For AI agents

Access Priority ERP entities via OData for CRUD operations, subform navigation, batch processing, and metadata management. Supports dynamic form paths across all Priority business modules.

## Scope

Does not handle payroll, HR workflows, or CRM pipeline management - use for OData CRUD and batch access to Priority ERP financial and operational entities only.

## Capabilities

- Query Priority ERP forms with OData filtering, sorting, pagination, and field selection
- Execute batch operations combining up to 100 requests in a single API call
- Navigate parent-child form relationships through subform entity paths
- Clear and rebuild entity metadata cache after form customizations
- Create and update business records in any Priority form via dynamic entity paths
- Retrieve system version and OData version information for environment validation
- Expand related entities inline to reduce round-trip queries

## Use cases

### Batch ERP Data Operations

Execute multiple Priority ERP operations in a single request using the batch endpoint. The API supports combining up to 100 create, update, or delete operations into one batch call, reducing network overhead and ensuring atomic-like processing. This is critical for high-volume data synchronization between external systems and Priority ERP, such as importing daily sales orders or updating inventory counts across multiple warehouses.

Example prompt: Execute a batch request to create 3 new entities in the ORDERS form, each with a different CUSTNAME and CURDATE value, and verify all return 201 status

### Dynamic Form Querying with OData

Access any Priority ERP form using dynamic entity set paths and OData query parameters. The API accepts the form name as a URL path segment and supports $filter, $select, $expand, $top, $skip, and $orderby for precise data retrieval. Agents can construct queries against ORDERS, CUSTOMERS, INVOICES, INVENTORY, or any configured Priority form without hardcoded path knowledge.

Example prompt: Query the CUSTOMERS entity set with $filter 'STATDES eq Active', $select 'CUSTNAME,PHONE,EMAIL', and $top 25 to retrieve the first page of active customers

### Subform Data Navigation

Access child entities related to a parent record by navigating subform paths. Priority ERP uses a parent-child form hierarchy where orders contain order items, invoices contain line details, and customers contain contacts. The API exposes these relationships through URL path navigation, allowing agents to drill into related data without separate lookup queries.

Example prompt: Retrieve order 'SO-2026-001' from the ORDERS entity set, then access its ORDERITEMS subform and create a new line item with part number 'WIDGET-A' and quantity 50

### AI Agent ERP Automation via Jentic

AI agents can access the full depth of Priority ERP through Jentic without managing OData URL construction or credential rotation. Jentic maps natural language intents to Priority operations, provides request schemas with parameter descriptions, and isolates credentials so agents never see raw Basic Auth passwords or bearer tokens in their context.

Example prompt: Search Jentic for 'batch update priority erp records', load the batchRequest operation schema, and execute a batch containing 2 PATCH operations to update customer phone numbers

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/` | List available entity sets in this Priority instance |
| GET | `/$metadata` | Retrieve full OData schema metadata |
| GET | `/{entitySet}` | Query entities with OData parameters |
| POST | `/{entitySet}` | Create a new entity in a Priority form |
| PATCH | `/{entitySet}('{key}')` | Update an entity by key |
| DELETE | `/{entitySet}('{key}')` | Delete an entity by key |
| POST | `/$batch` | Execute batch of up to 100 operations |
| POST | `/ClearEntityMetadata` | Clear and rebuild form metadata cache |

## Key resources

- **Metadata** — List entity sets, retrieve OData schema, check version, get OData version, and clear metadata cache
- **Entities** — CRUD operations on dynamic Priority form entities with OData query support
- **Batch** — Execute multiple operations (up to 100) in a single request for bulk processing

## 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:** 61 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 76 / 100
  - Developer Experience & Jentic Compatibility: 63 / 100
  - AI-Readiness & Agent Experience: 50 / 100
  - Agent Usability: 94 / 100
  - Security: 35 / 100
  - AI Discoverability: 100 / 100
- **View full report:** https://jentic.com/apis/prioritysoftware.com/prioritysoftware/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 the Priority REST API by hand means choosing Basic auth or a bearer token, assembling the templated OData host with your domain, tabula.ini, and instance, and handling the {entitySet} path and $batch calls yourself. Through Jentic you install once, import the Priority REST API from the API Directory, store the credentials once, and your agent calls it.
- **Permission scoping:** Priority puts the entity key in the URL path (/{entitySet}('{key}')), so a rule can pin your agent to specific entity records. You choose the operations it may call, so a destructive one like DELETE or a $batch write is not included unless you add it.
- **Credential handling:** Your Priority Basic auth credentials or bearer token are stored once, encrypted, by your own Jentic One instance and injected at execution time. They never enter the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a sales order in Priority' or 'batch update inventory', and Jentic returns the matching Priority operation with its input schema, including the dynamic entity set path variable, so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Priority Software REST API** — Vendor-official spec for the same Priority ERP with PAT and app license auth options
- **Priority REST API** — Vendor-official OData spec with OAuth2 and PAT support plus batch operations
- **Shopify API** — E-commerce storefront to sync orders with Priority ERP back-office

## FAQ

### Why is there no official OpenAPI spec for Priority REST API?

Priority Software does not publish an OpenAPI specification for this API variant. Jentic generates and maintains this spec so that AI agents and developers can call Priority REST 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 Priority REST API use?

The API supports Basic authentication with your Priority username and password, and Bearer token authentication using Personal Access Tokens (PAT) or OAuth2 tokens. Through Jentic, these credentials are stored encrypted in the vault. Agents authenticate without handling raw passwords or token strings.

### How many operations can I include in a batch request?

The Priority REST API supports up to 100 operations per batch request via POST /$batch. Each operation in the batch can be a create, update, or delete against any entity set. The batch executes operations sequentially and returns individual status codes for each operation in the response.

### Can I access Priority subform data through the API?

Yes. Use the path pattern /{entitySet}('{key}')/{subform} to access child entities. For example, GET /ORDERS('ORD001')/ORDERITEMS returns all line items for that order. You can also POST to the same path to create new subform entities linked to the parent record.

### How do I clear the metadata cache after customizing a Priority form?

Call POST /ClearEntityMetadata with an optional JSON body containing the Entity field set to the form name you customized. This rebuilds the REST metadata for that form. If you omit the Entity field, metadata for all forms is rebuilt. This is necessary after adding or removing fields from Priority forms.

### How do I query Priority ERP data through Jentic?

Search Jentic for 'list priority erp entities', load the listEntities operation schema, and execute with the entitySet path parameter set to the form name (e.g., 'ORDERS'). Add OData query parameters like $filter, $top, and $select to narrow results. Install with pip install jentic and set JENTIC_AGENT_API_KEY.

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

Yes. Because you run Jentic One yourself, your own rules decide which Priority operations the agent may call, so you can grant read-only access to entity sets like ORDERS or CUSTOMERS while withholding a destructive DELETE or a POST /$batch write. Priority puts the entity key in the URL path, such as /{entitySet}('{key}'), so a rule can pin the agent to specific records rather than every entity in a form. Your Basic auth credentials or bearer token stay with your instance and are injected only for the operations you have allowed.