canonical: https://jentic.com/apis/docs.ifs.com/ifs

# Docs Ifs IFS Applications API

The IFS Applications API exposes the OData projection layer that sits on top of IFS Cloud and IFS Applications ERP. The two endpoints in this spec list available projections and return the OpenAPI document for any specific projection, which is the bootstrap step before working with IFS business data such as orders, invoices or work orders. Authenticated via HTTP Basic, this is essentially a discovery API for the rest of the IFS projection surface.

## For AI agents

Discover available IFS Applications projections and pull the OpenAPI spec for a chosen projection so that further IFS ERP calls can be made.

## Scope

Does not handle direct IFS business operations such as orders, invoices, or work orders, nor IFS UI rendering - use for projection discovery and spec retrieval only.

## Capabilities

- List all OData projections exposed by the IFS server
- Retrieve the OpenAPI document for a named projection
- Bootstrap deeper IFS Applications integrations by feeding projection specs into client generators
- Verify that a projection is available and reachable on a customer's IFS environment
- Authenticate against an IFS server with HTTP Basic credentials

## Use cases

### IFS Integration Bootstrap

Before an integration team can hit IFS business endpoints, they need to know which projections the customer has enabled. GET `/main/ifsapplications/projection/v1/AllProjections.svc/Projections` returns that list. The team then calls `/int/ifsapplications/projection/v1/{projectionName}.svc`/$openapi to pull the OpenAPI document for the specific projection they care about, generating a typed client from there.

Example prompt: GET `/main/ifsapplications/projection/v1/AllProjections.svc/Projections` and parse the response, then GET `/int/ifsapplications/projection/v1/CustomerOrderHandling.svc`/$openapi to retrieve its spec.

### ERP Integration Health Checks

An operations team running an integration platform connected to IFS can use these endpoints as a continuous health check. If the projection list endpoint returns 200 with the expected projection, the IFS instance is reachable, authenticated and exposing the right data layer. A failed call signals credential or environment drift before downstream integrations break.

Example prompt: Call the projections list endpoint every 5 minutes and alert if the response is non-200 or missing the configured projection names.

### Projection Drift Detection

Customers upgrade IFS environments often, and projection schemas can change between releases. Pulling `/int/ifsapplications/projection/v1/{projectionName}.svc`/$openapi on a schedule and diffing against a stored copy gives integration teams an early warning when a field is added, renamed or removed in a downstream-critical projection.

Example prompt: GET `/int/ifsapplications/projection/v1/CustomerOrderHandling.svc`/$openapi and diff the result against the previous run, flagging any added or removed properties.

### AI Agent IFS Integration Helper

Through Jentic, an integration engineer's AI assistant can answer 'which IFS projections are available on the staging server?' and 'show me the schema for the WorkOrder projection'. The agent searches Jentic, loads the projection list or spec retrieval operation, and executes against the configured IFS host. Useful for accelerating IFS integration scoping work.

Example prompt: Use Jentic to search 'list IFS projections', load the projections list operation and execute it against a staging IFS host to summarise which projections exist.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/main/ifsapplications/projection/v1/AllProjections.svc/Projections` | List all available projections on the server |
| GET | `/int/ifsapplications/projection/v1/{projectionName}.svc/$openapi` | Retrieve the OpenAPI spec for a specific projection |

## Key resources

- **Projections** — List of OData projections exposed by the IFS server
- **Projection Specs** — OpenAPI documents for individual named projections

## Why Jentic

- **Setup:** Wiring the IFS Applications API by hand means setting up Basic auth against an IFS service account, filling in the server and port for your own IFS host, and knowing which projection to query before you can even read a spec. Through Jentic you install once, import the IFS Applications API from the API Directory, store the Basic credentials once, and your agent calls it.
- **Permission scoping:** Both IFS operations here are read-only projection discovery and spec retrieval, so scope by operation: limit the agent to listing projections and fetching a projection's OpenAPI document, and nothing that touches ERP business data. You choose which of these two operations it may call, so it never reaches beyond projection metadata.
- **Credential handling:** Your IFS Basic-auth credentials 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 'list IFS projections' or 'get an IFS projection spec', and Jentic returns the matching operation on `/AllProjections.svc/Projections` or /{projectionName}.svc/$openapi with its parameter schema so the agent calls the right endpoint without parsing the IFS docs.

## Related APIs

- **DigitalOcean API** — Hosts custom integration services that consume IFS projection specs
- **GitHub API** — Source-control API - alternative discovery surface when projection specs are versioned in a repo rather than fetched live
- **Asana API** — Track IFS-related tasks in Asana alongside ERP records.
- **Slack API** — Notify Slack channels when IFS document state changes.

## FAQ

### What authentication does the IFS Applications API use?

The IFS Applications projection layer uses HTTP Basic authentication against the customer's IFS server. Credentials are usually a service account scoped to the projections that integration users need. Through Jentic, the username and password live in your Jentic One instance rather than in code or environment variables.

### Can I list all projections on an IFS server with this API?

Yes. GET `/main/ifsapplications/projection/v1/AllProjections.svc/Projections` returns the projections exposed on the server, which is typically the first call any IFS integration makes.

### What are the rate limits for the IFS Applications API?

Rate limits depend on the customer's IFS deployment and any reverse proxy in front of it; the spec does not define a vendor-side limit. Treat the API as discovery-only and avoid polling the projection list more than once per minute in normal use.

### How do I retrieve the OpenAPI spec for a projection through Jentic?

Search Jentic for 'get IFS projection OpenAPI', load the `/int/ifsapplications/projection/v1/{projectionName}.svc`/$openapi operation and execute it with the projection name. The Basic auth credentials remain in your Jentic One instance.

### Why does this API only have two endpoints?

This spec covers the discovery layer only. Each projection (for example CustomerOrderHandling, WorkOrderHandling) has its own OpenAPI document that you fetch via the second endpoint, then use to call business operations on IFS.

### Is the IFS Applications API free?

API access is included with an IFS Cloud or IFS Applications licence. There is no separate API metering fee - you are governed by your IFS contract and the projections your administrator has enabled.

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

Yes. Because your Jentic One instance is self-hosted, your own rules decide which operations and credentials the agent may use. This API exposes only two read-only operations, so you can allow the agent to list projections and fetch a projection's OpenAPI document while blocking anything else. Scoped this way, the agent stays on projection metadata and never reaches IFS ERP business data such as orders, invoices, or work orders.