---
title: Avara Express | Avara
description: Learn how to set up Avara Express to sell AutoScribe or Viewer as a service to your customers. Perfect for PACS, EHR, and RIS companies looking to monetize radiology workflows.
---

## Introduction

**Avara Express** is a platform account model that enables companies to sell AutoScribe or Viewer as a service to their customers. Similar to Stripe Express for payments, Avara Express handles multi-tenant complexity, allowing you to host multiple customers under one platform account with robust study access permissions scoping based on customer membership.

This PACS-first design makes it easy to integrate Avara Viewer or AutoScribe into your platform to maximize revenue while providing your customers with best-in-class radiology tools.

## What is Avara Express?

Avara Express allows you to:

- **Act as a platform account** — Host all of your customers’ users with one Avara account
- **Sell as a service** — Offer AutoScribe or Viewer to your customers as a white-labeled or branded solution
- **Manage multiple customers** — Each customer gets their own customer ID with strong isolation
- **Control access** — Users can only see studies from customers they belong to
- **Scale easily** — Add new customers in seconds via dashboard or SDK

## Key Concepts

### Express Customers

Each customer you serve gets an **Express Customer ID** (`cus_{32-hex-chars}`). This ID is used to:

- Group users into customers
- Scope study access permissions
- Track usage and billing per customer

### User-Customer Relationships

Users can be added to one or more Express customers. This enables:

- **Strong isolation** — Users can only see studies associated with their customer(s)
- **Multi-customer support** — Users can belong to multiple customers if there’s overlap
- **Flexible access** — Perfect for scenarios where radiologists work across multiple facilities

### Study Access Control

Each study must have an `expressCustomerId` attached to it. This determines visibility:

- **Customer members** — Can see studies for customers they belong to
- **Platform admins** — Can view all studies across all customers (intended for hosting company staff only)
- **Unattached studies** — Only visible to platform admins

### Platform Admins

Platform admins are special users with elevated permissions:

- **Full visibility** — Can view all studies across all Express customers
- **Customer management** — Can create, update, and manage Express customers
- **User management** — Can add users to any customer

**Important:** Platform admins are meant for the hosting company only, not for end customers.

## Enabling Avara Express

### Dashboard Setup

1. Navigate to **Settings** in the sidebar
2. Find the **Avara Express** section
3. Click **Enable Avara Express**
4. Confirm the action

**⚠️ Important:** Once Avara Express is enabled, **it cannot be disabled**. This is a permanent account-level setting.

### What Happens After Enabling

Once enabled:

- A new **Express Customers** tab appears in the sidebar
- You can create and manage Express customers via the dashboard
- Full SDK support becomes available for programmatic customer management
- Study creation endpoints accept `expressCustomerId` parameters

## Creating Express Customers

### Via Dashboard

1. Click the **Express Customers** tab in the sidebar
2. Click **Create Customer**
3. Enter the customer name
4. Optionally add metadata (key-value pairs for custom tracking)
5. Click **Create**

The customer is created instantly with a unique Express Customer ID.

### Via SDK

Express customers can be created programmatically using the Express API:

#### TypeScript

```
import Avara from '@avara/sdk';


const avara = new Avara({ apiKey: process.env.AVARA_API_KEY });


const expressCustomer = await avara.express.create({
  expressCustomerName: 'City Medical Center',
  metadata: {
    department: 'radiology',
    region: 'northeast',
  },
});


console.log(expressCustomer.expressCustomerId); // cus_1234567890abcdef...
```

#### Python

```
from avara import Avara


avara = Avara(api_key=os.environ['AVARA_API_KEY'])


express_customer = avara.express.create(
    express_customer_name='City Medical Center',
    metadata={
        'department': 'radiology',
        'region': 'northeast',
    }
)


print(express_customer.express_customer_id)  # cus_1234567890abcdef...
```

#### Java

```
import com.avara.Avara;
import com.avara.models.express.*;


Avara avara = new Avara.Builder()
    .apiKey(System.getenv("AVARA_API_KEY"))
    .build();


ExpressCustomerCreateRequest request = ExpressCustomerCreateRequest.builder()
    .expressCustomerName("City Medical Center")
    .metadata(Map.of(
        "department", "radiology",
        "region", "northeast"
    ))
    .build();


ExpressCustomer expressCustomer = avara.express().create(request);
System.out.println(expressCustomer.getExpressCustomerId()); // cus_1234567890abcdef...
```

## Managing Users

### Adding Users to Customers

Users must first be invited and accept their invitation before they can be added to Express customers.

#### Via Dashboard

1. Go to the **Express Customers** tab
2. Click on a customer
3. Click **Add User**
4. Select a user from the list (users must have accepted their invitation)
5. Click **Add**

The user can now see studies associated with that Express customer.

#### Via SDK

Users can be added to Express customers programmatically:

#### TypeScript

```
await avara.express.addUser(expressCustomerId, {
  userId: 'usr_1234567890abcdef1234567890abcdef',
});
```

#### Python

```
avara.express.add_user(
    express_customer_id='cus_1234567890abcdef1234567890abcdef',
    user_id='usr_1234567890abcdef1234567890abcdef'
)
```

#### Java

```
ExpressCustomerAddUserRequest request = ExpressCustomerAddUserRequest.builder()
    .userId("usr_1234567890abcdef1234567890abcdef")
    .build();


avara.express().addUser(expressCustomerId, request);
```

### Multi-Customer Users

Users can belong to multiple Express customers. This is useful when:

- A radiologist works at multiple facilities
- Practices share staff across locations

When a user belongs to multiple customers, they can see studies from all customers they’re associated with.

## Creating Studies with Express Customers

When creating studies, you must attach an `expressCustomerId` to make them visible to customer members.

### AutoScribe Studies

#### TypeScript

```
const study = await avara.autoScribe.studies.create({
  studyInstanceUid: '1.2.840.113619.2.55.3.604688119.868.1234567890.123',
  studyDescription: 'Brain MRI with Contrast',
  severity: 'normal',
  expressCustomerId: 'cus_1234567890abcdef1234567890abcdef', // Required for Express
  reportMetadata: {
    scanDate: '2024-03-15',
    scanType: 'MRI Brain with Contrast',
    patientName: 'Jane Doe',
    facilityName: 'City Medical Center',
    sex: 'female',
    dateOfBirth: '1985-07-20',
    mrn: 'MRN-2024-001234',
  },
});
```

#### Python

```
study = avara.auto_scribe.studies.create(
    study_instance_uid='1.2.840.113619.2.55.3.604688119.868.1234567890.123',
    study_description='Brain MRI with Contrast',
    severity='normal',
    express_customer_id='cus_1234567890abcdef1234567890abcdef',  # Required for Express
    report_metadata={
        'scan_date': '2024-03-15',
        'scan_type': 'MRI Brain with Contrast',
        'patient_name': 'Jane Doe',
        'facility_name': 'City Medical Center',
        'sex': 'female',
        'date_of_birth': '1985-07-20',
        'mrn': 'MRN-2024-001234',
    }
)
```

#### Java

```
AutoScribeStudyCreateRequest request = AutoScribeStudyCreateRequest.builder()
    .studyInstanceUid("1.2.840.113619.2.55.3.604688119.868.1234567890.123")
    .studyDescription("Brain MRI with Contrast")
    .severity(Severity.NORMAL)
    .expressCustomerId("cus_1234567890abcdef1234567890abcdef") // Required for Express
    .reportMetadata(StudyReportMetadata.builder()
        .scanDate("2024-03-15")
        .scanType("MRI Brain with Contrast")
        .patientName("Jane Doe")
        .facilityName("City Medical Center")
        .sex(Sex.FEMALE)
        .dateOfBirth("1985-07-20")
        .mrn("MRN-2024-001234")
        .build())
    .build();


AutoScribeStudy study = avara.autoScribe().studies().create(request);
```

### Viewer Studies

#### TypeScript

```
const study = await avara.viewer.studies.create({
  studyInstanceUid: '1.2.840.113619.2.55.3.604688119.868.1234567890.123',
  studyDescription: 'CT Chest/Abdomen/Pelvis',
  severity: 'high',
  expressCustomerId: 'cus_1234567890abcdef1234567890abcdef', // Required for Express
});
```

#### Python

```
study = avara.viewer.studies.create(
    study_instance_uid='1.2.840.113619.2.55.3.604688119.868.1234567890.123',
    study_description='CT Chest/Abdomen/Pelvis',
    severity='high',
    express_customer_id='cus_1234567890abcdef1234567890abcdef',  # Required for Express
)
```

#### Java

```
ViewerStudyCreateRequest request = ViewerStudyCreateRequest.builder()
    .studyInstanceUid("1.2.840.113619.2.55.3.604688119.868.1234567890.123")
    .studyDescription("CT Chest/Abdomen/Pelvis")
    .severity(Severity.HIGH)
    .expressCustomerId("cus_1234567890abcdef1234567890abcdef") // Required for Express
    .build();


ViewerStudy study = avara.viewer().studies().create(request);
```

## Access Control Behavior

### For Customer Members

Users who belong to an Express customer can:

- ✅ See studies with that customer’s `expressCustomerId`
- ✅ Create reports (AutoScribe) or view studies (Viewer) for their customer
- ❌ See studies from other customers they don’t belong to

### For Platform Admins

Platform admins (hosting company staff) can:

- ✅ View all studies across all Express customers
- ✅ Create and manage Express customers
- ✅ Add users to any customer
- ✅ Access all platform features

**Note:** Platform admins are intended for your company’s staff only, not for end customers.

### For Studies Without Express Customer ID

Studies created without an `expressCustomerId`:

- ❌ Are **not visible** to customer members
- ✅ Are **only visible** to platform admins

Always attach an `expressCustomerId` when creating studies for Express customers.

## Managing Express Customers

### Listing Customers

#### TypeScript

```
const response = await avara.express.list({
  limit: 20,
});


for (const customer of response.expressCustomers) {
  console.log(`${customer.expressCustomerName}: ${customer.expressCustomerId}`);
  console.log(`Active: ${customer.isActive}, Users: ${customer.userCount}`);
}
```

#### Python

```
response = avara.express.list(limit=20)


for customer in response.express_customers:
    print(f"{customer.express_customer_name}: {customer.express_customer_id}")
    print(f"Active: {customer.is_active}, Users: {customer.user_count}")
```

#### Java

```
ExpressCustomerListResponse response = avara.express().list(
    ExpressCustomerListParams.builder()
        .limit(20)
        .build()
);


for (ExpressCustomer customer : response.getExpressCustomers()) {
    System.out.println(customer.getExpressCustomerName() + ": " + customer.getExpressCustomerId());
    System.out.println("Active: " + customer.getIsActive() + ", Users: " + customer.getUserCount());
}
```

### Updating Customers

#### TypeScript

```
const updated = await avara.express.update(expressCustomerId, {
  expressCustomerName: 'City Medical Center - Updated',
  metadata: {
    department: 'radiology',
    region: 'northeast',
    wing: 'Building A',
  },
});
```

#### Python

```
updated = avara.express.update(
    express_customer_id='cus_1234567890abcdef1234567890abcdef',
    express_customer_name='City Medical Center - Updated',
    metadata={
        'department': 'radiology',
        'region': 'northeast',
        'wing': 'Building A',
    }
)
```

#### Java

```
ExpressCustomerUpdateRequest request = ExpressCustomerUpdateRequest.builder()
    .expressCustomerName("City Medical Center - Updated")
    .metadata(Map.of(
        "department", "radiology",
        "region", "northeast",
        "wing", "Building A"
    ))
    .build();


ExpressCustomer updated = avara.express().update(expressCustomerId, request);
```

### Removing Users from Customers

#### TypeScript

```
await avara.express.removeUser(expressCustomerId, {
  userId: 'usr_1234567890abcdef1234567890abcdef',
});
```

#### Python

```
avara.express.remove_user(
    express_customer_id='cus_1234567890abcdef1234567890abcdef',
    user_id='usr_1234567890abcdef1234567890abcdef'
)
```

#### Java

```
ExpressCustomerRemoveUserRequest request = ExpressCustomerRemoveUserRequest.builder()
    .userId("usr_1234567890abcdef1234567890abcdef")
    .build();


avara.express().removeUser(expressCustomerId, request);
```

### Deactivating Customers

#### TypeScript

```
const deactivated = await avara.express.deactivate(expressCustomerId);
```

#### Python

```
deactivated = avara.express.deactivate('cus_1234567890abcdef1234567890abcdef')
```

#### Java

```
ExpressCustomer deactivated = avara.express().deactivate(expressCustomerId);
```

### Reactivating Customers

#### TypeScript

```
const reactivated = await avara.express.reactivate(expressCustomerId);
```

#### Python

```
reactivated = avara.express.reactivate('cus_1234567890abcdef1234567890abcdef')
```

#### Java

```
ExpressCustomer reactivated = avara.express().reactivate(expressCustomerId);
```

## Best Practices

### 1. Always Attach Express Customer ID

When creating studies for Express customers, always include the `expressCustomerId`. Studies without this ID are only visible to platform admins.

### 2. Use Platform Admins Sparingly

Platform admins have access to all studies across all customers. Only grant admin access to your company’s staff, not to end customers.

### 3. Organize Users by Customer

Add users to the appropriate Express customers immediately after they accept their invitations. This ensures they can access the correct studies from day one.

### 4. Track Customer Usage

Use Express customer metadata to track custom information:

- Department or facility name
- Region or location
- Billing codes
- Custom identifiers

### 5. Handle Multi-Customer Users

If users work across multiple facilities, add them to all relevant Express customers. They’ll be able to see studies from all customers they belong to.

## Use Cases

### PACS Companies

PACS companies can use Avara Express to:

- Offer AutoScribe dictation as a native feature
- Provide Viewer access to their customers
- Generate new revenue streams from existing customers
- Differentiate from competitors with integrated workflows

### EHR/RIS Companies

EHR and RIS companies can:

- Embed radiology workflows into their platforms
- Offer white-labeled dictation and viewing solutions
- Provide seamless integration without separate logins
- Scale to serve multiple healthcare facilities

## Summary

Avara Express enables you to:

- ✅ Host multiple customers with one platform account
- ✅ Provide strong isolation between customers
- ✅ Add new customers in seconds via dashboard or SDK
- ✅ Control study access based on customer membership
- ✅ Scale your business by selling AutoScribe or Viewer as a service

Once enabled, Avara Express cannot be disabled, so ensure this model fits your business needs before enabling. For questions or assistance with setup, contact our sales team.