> ## Documentation Index
> Fetch the complete documentation index at: https://storekit.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Order Batching

> Group multiple storekit orders from the same table into a single consolidated kitchen ticket. Reduce ticket noise and give the kitchen a complete table view.

Order batching combines multiple orders from the same table into one consolidated order before sending to the kitchen or POS. This reduces ticket noise and gives the kitchen a complete view of what a table has ordered.

## How It Works

Without batching, each time a guest at a table orders something, a separate ticket prints in the kitchen. With batching enabled:

1. Guest places first order → order is held in a batch
2. Guest places second order → added to the same batch
3. After the timeout period, the batch closes
4. All orders merge into one ticket and send to kitchen/POS

```
Without batching:           With batching:
┌─────────────┐            ┌─────────────┐
│ Ticket #1   │            │ Ticket #1   │
│ 1x Burger   │            │ 1x Burger   │
└─────────────┘            │ 1x Fries    │
┌─────────────┐            │ 2x Beer     │
│ Ticket #2   │            │ 1x Wings    │
│ 1x Fries    │     →      └─────────────┘
└─────────────┘                  
┌─────────────┐            (Single consolidated
│ Ticket #3   │             ticket after timeout)
│ 2x Beer     │
└─────────────┘
┌─────────────┐
│ Ticket #4   │
│ 1x Wings    │
└─────────────┘
```

## When Orders Are Batched

Orders are grouped into the same batch when:

* **Same table** - Orders must be from the same table
* **Within timeout window** - Orders placed within the configured timeout period
* **In-Store fulfillment only** - Batching only applies to dine-in orders

<Tip>
  Pickup and Delivery orders are never batched - they always go straight to the kitchen.
</Tip>

## Smart Batch Closing

storekit uses a smart algorithm to determine when to close a batch, balancing speed with consolidation.

### How It Works

The system monitors whether anyone at the table is still browsing the menu or building an order:

* **Someone still ordering?** → Batch stays open (up to the timeout limit)
* **Everyone finished?** → Batch closes immediately

This means if one person places an order and no one else at the table has the menu open, the batch closes straight away - no unnecessary waiting. But if others are still deciding, the system waits for them.

### Example

```
12:00:00 - Alice orders a burger (batch opens)
12:00:05 - System detects Bob has menu open → batch stays open
12:01:30 - Bob orders fries (added to batch)
12:01:35 - No one else browsing → batch closes immediately
12:01:35 - Merged order sent to kitchen
```

Compare this to a simple 5-minute timeout where the kitchen would wait until 12:05:00 - that's over 3 minutes saved.

### Timeout Limit

If guests keep browsing, the batch won't stay open forever. There's a maximum timeout (up to 5 minutes) after which the batch closes regardless. This ensures orders always reach the kitchen in a reasonable time.

| Timeout         | Best for                   |
| --------------- | -------------------------- |
| 1-2 minutes     | Fast-casual, quick top-ups |
| 3 minutes       | Standard table service     |
| 5 minutes (max) | Groups ordering together   |

## Merged Order Contents

When a batch closes, orders are intelligently merged:

| Element            | How it's merged                                      |
| ------------------ | ---------------------------------------------------- |
| **Items**          | Combined, with quantities summed for identical items |
| **Modifiers**      | Items with different modifiers kept separate         |
| **Totals**         | All order totals, tips, and service charges summed   |
| **Notes**          | Optionally included (configurable)                   |
| **Customer names** | Optionally listed (configurable)                     |

### Item Merging Example

```
Order 1: 1x Burger (no onions)
Order 2: 1x Burger (extra cheese)
Order 3: 1x Burger (no onions)

Merged result:
- 2x Burger (no onions)    ← quantities combined
- 1x Burger (extra cheese) ← kept separate (different modifier)
```

## Configuration

### Store-Wide Settings

Go to **Store Settings > Operations** and configure:

| Setting                 | Description                            | Default |
| ----------------------- | -------------------------------------- | ------- |
| **Enabled**             | Turn batching on/off                   | Off     |
| **Timeout**             | Minutes before batch closes            | 5       |
| **Show notes**          | Include customer notes in merged order | Off     |
| **Show customer names** | List all customer names on ticket      | Off     |

### Disabling Batching for Specific Tables

You can disable batching for individual tables or sections by setting their batch timeout to 0. Orders from those tables will go straight to the kitchen without waiting.

This is useful for bar seating or quick-service areas where guests typically order one item at a time.

## Integration with POS Systems

When a batch closes, the merged order is sent to your connected systems:

* **POS systems** - Deliverect, Lightspeed, Zonal, Tissl, PointOne, Comtrex, Ikentoo
* **Printers** - CloudPRNT enabled printers

The POS receives one order containing all items from the batch, making it easier to manage the table's bill.

## Send to Kitchen

When batching is enabled, guests see a **Send to Kitchen** button after placing their order. This allows them to close the batch early instead of waiting for the timeout.

The button appears with a countdown timer showing how long until the batch auto-closes. If the guest knows they're done ordering, they can tap the button to immediately send all orders to the kitchen.

This is useful when:

* A guest is ordering alone and doesn't need the full timeout
* The table has finished ordering and wants their food sooner
* A quick top-up order that should go straight through

## Best Practices

1. **Match timeout to service style** - Fast-casual needs shorter timeouts than fine dining
2. **Enable customer names** - Helps kitchen identify who ordered what at large tables
3. **Train staff** - Ensure servers know batches will be held before going to kitchen
4. **Consider bar vs table** - Use table-specific timeouts for different seating areas
