---
title: Avra Core
description: The delivery layer for Avra's models — live predictions and batch inference into the systems you run, with versions, webhooks, and access controls around them.
sidebar:
  label: Overview
---

Avra Core is how Avra's models reach your systems. It serves [Avra RFM](/rfm), [Avra GFM](/gfm), and the models built on them the same way, live or in batch, with the controls your team needs around them. It's for builders: your engineering and data teams, and the Avra engineers who work alongside them.

The workflow is the same whichever model you call. You create an API key for a workspace, find the model and the version you want, read the inputs that version's schema declares, and send them: one record at a time through the live API, or whole files through batch inference. Versions and aliases decide which version answers, webhooks tell your systems when something changes, and roles and logs record who did what.

## How Core reaches your systems

Every model available to your organization has versions, and an alias such as `production` points at one of them. Your systems call a version directly or through its alias, live or in batch, and webhooks report events to your systems as they happen.

```mermaid
flowchart LR
  subgraph core["Avra Core"]
    direction TB
    models["Models<br/>RFM, GFM, downstream"] --> versions["Versions and aliases"]
  end
  versions -->|"Live predictions"| engine["Decision engine"]
  versions -->|"Batch inference"| lake["Warehouse and pipelines"]
  core -.->|"Webhooks"| systems["Your systems"]
  class versions accent
  classDef accent fill:#0A01FE,stroke:#0A01FE,color:#fff
```

## Live or batch

| | Live predictions | Batch inference |
|---|---|---|
| **You send** | One record per request, as JSON | Parquet or CSV files with many records |
| **You get back** | The outputs the version declares, in the response | One `result.parquet` per batch |
| **Endpoints** | `POST /v1/api/prediction/{model_id}/{alias_or_version_id}` | `POST /v1/api/files/upload`, then `POST /v2/api/batches` |
| **Timing** | Synchronous: the answer comes back in the response | Asynchronous: poll the batch, or subscribe to webhooks |
| **Limits** | About 100 requests per 10 seconds per API key | Enabled per organization; doesn't count against the prediction limit |
| **Use it for** | Onboarding, underwriting one application at a time | Nightly portfolio rescoring, list enrichment |

Use [live predictions](/core/predictions) when a decision waits on the answer: an onboarding step or an underwriting call. Use [batch inference](/core/batch-inference) for more than a few thousand records at once, such as rescoring a whole portfolio every night. You can use both against the same model: batch to score the book every night, and live for the new requests that arrive during the day.

Every output a model declares comes back the same way, on either path. GFM embeddings, for example, are one of the GFM's outputs: fetch them live or in batch, then add them to the models you already run. See [Build with embeddings](/gfm/embeddings).

Core's limits are collected in [Limits and quotas](/core/limits), with what happens when you reach each one.

## The models it serves

Core serves every model available to your organization through the same endpoints. [Avra RFM](/rfm) predicts your own targets from your own data, and [Avra GFM](/gfm) returns probabilities of default and embeddings for Brazilian companies, through Core only. Downstream models, such as a credit model trained on GFM embeddings together with your features and outcomes, are served the same way. An adapted or fine-tuned copy of the RFM is released as a version like any other, exclusive to your workspace. See [Models](/models) for how the models compare.

## The controls around them

[Versions and aliases](/core/model-versioning) let you promote, pin, and roll back. [Webhooks](/core/webhooks) report events for batches, model versions, workspaces, and API keys. Access comes from API keys scoped to a workspace, roles, and an audit log, all in the [dashboard](/dashboard). The usage log records every prediction a workspace served. See [Audit and usage logs](/dashboard/audit-logs).

| Control | What it does | Where |
|---|---|---|
| **API keys** | Authenticate every call, scoped to one workspace | **Settings → Workspace → API keys** |
| **Versions and aliases** | Decide which version answers a call | **Models**, on each model's page |
| **Roles** | Decide who can move aliases, create batches, and manage webhooks | [Roles and permissions](/dashboard/roles-permissions) |
| **Webhooks** | Send events to your endpoints over HTTPS | **Alerts → Webhooks** |
| **Audit and usage logs** | Record account activity and every prediction served | **Observability** |

## Get started

1. **Create an API key**

    In the [dashboard](https://app.avra.ai), open **Settings → Workspace → API keys** in the workspace the key is for, create a key, and keep it in an environment variable such as `AVRA_API_KEY`.

2. **Find the model**

    List the models available to your organization with `GET /v1/api/models`, then read a version's schema with `GET /v1/api/models/{model_id}/versions/{alias_or_version_id}`.

3. **Call it**

    Send the inputs the schema declares to `POST /v1/api/prediction/{model_id}/production`. See [Live predictions](/core/predictions), or the [Quickstart](/quickstart) for a first call, step by step.

## Where to go next

**[Live predictions](/core/predictions)**

Call a model one record at a time, handle errors, and retry safely.

**[Batch inference](/core/batch-inference)**

Upload files, run a batch, and download the results.

**[Model versioning](/core/model-versioning)**

Pin a version, follow an alias, promote, and roll back.

**[Webhooks](/core/webhooks)**

Receive events, verify signatures, and handle retries.

**[Models](/models)**

Compare Avra RFM and Avra GFM, and find the one for your question.

**[Limits and quotas](/core/limits)**

Every rate limit, size limit, and expiration in one place.
