Glossary

Auction Mechanics

StartingBid

The starting bid is the minimum amount required for the first valid bid on an item. Any bid below this value will be automatically rejected.

When no bids exist on an item, the starting bid is the first value found in the nextAsks.

Key Points:

• Expressed in cents (e.g., 1000 = $10.00)
• Can be set independently of the increment table
• Does not guarantee the item will sell (see Reserve)

Off-Increment Behavior

The starting bid does not need to align with the increment table (i.e., it can be off-increment). However, if it is off-increment, the next valid ask (minimum accepted bid after that) will be calculated based on the nearest valid increment above the starting bid.

Off-Increment Example

Scenario: You define a starting bid of 1,170, which is off-increment based on the increment table.

Increment Table:

Behavior:

1. 1,170 is within the 1,000–2,000 range → increment is 50
2. Since 1,170 is off-increment, it is accepted only as the first valid bid
3. The next bid must align with the increment grid: 1,200, not 1,220

Resulting NextAsks Progression:

Example:

Bid Increment Table

The BidIncrementTable defines how much the next valid bid must increase based on the current bid amount. It ensures that bids follow a clear, predictable progression as auction prices rise.

Structure:

• lowRange: Start of price range (in cents)
• highRange: End of price range (in cents)
• step: Required increment within this range (in cents)

Example Table

Human-Friendly Interpretation (USD)

With the table above, here's how to read it:

• From $0 to $1,000 → bids increase by $25
• From $1,000 to $50,000 → bids increase by $100

If the bid exceeds the highest HighRange (in this case $50,000), the increment remains fixed at the last step: $100.

Validation Rules

To be valid, a BidIncrementTable must meet these requirements:

Each range must align:

• LowRange and HighRange must be divisible by Step
• Step must fit evenly within the range (HighRange - LowRange)

Rules must be continuous:

• The first rule must start at 0
• Each rule's LowRange must equal the previous rule's HighRange

At least one rule is required

Example:

Summary

• Controls how bid amounts increase over time
• Dynamic and price-dependent
• Keeps auction pacing smooth and scalable

Can be set at:

• Sale level: Applies to all items in the sale
• Item level: Overrides sale-level settings for specific items

NextAsks

The nextAsks property defines the upcoming valid bid amounts for an auctioned item. It helps clients display what the next acceptable bids will be, based on the current state of the auction.

What Influences nextAsks?

nextAsks is calculated from:

1. The current highest bid, or the startingBid if no bids have been placed
2. The calculation also considers the user context when a user has an active bid on the item
3. The rules in the bidIncrementTable

The system rounds the current amount down to the nearest valid increment and then applies the increment rule to generate the upcoming asks.

How It Works

• If no bids exist yet, the startingBid is used as the base
• The first value in nextAsks is always the minimum next valid bid
• Each subsequent ask increases by the applicable step from the bidIncrementTable
• If the startingBid is off-increment, the first ask is the startingBid, and the second ask snaps to the increment grid

Example A: Starting Bid Aligned to Increment

• startingBid: 1100
• Increment: 50

Resulting nextAsks:

All values align with the increment rule.

Example B: Starting Bid Off-Increment

• startingBid: 1170
• Increment: 50

Resulting nextAsks:

• 1170 is accepted as-is for the first ask
• 1200 is the first value that aligns with the increment rule
• All following asks increase from 1200 in steps of 50

Why It Matters

• nextAsks helps you render bid buttons, sliders, or preset options in the UI
• It ensures clients always show valid and enforceable bid amounts
• It reflects dynamic increments based on bid ranges — no hardcoding required

Reserve

The reserve is the minimum price that must be met for an auctioned item to have a valid winning bid when it closes.

If the highest bid does not meet or exceed the reserve price by the time the item reaches status CLOSED, no winner is declared.

Purpose

• Protects sellers from selling below a minimum acceptable value
• Ensures auctions can start at a low startingBid while still enforcing a threshold for winning

Behavior

• If the final bid is below the reserve, the auction closes without a winner
• The reserve is not visible to other bidders (unless revealed by the client)
• Expressed in cents (e.g., 200000000 = $2,000,000)

Reserve Statuses:

• NOT_MET: Current bid is below the reserve
• MET: Current bid has reached or exceeded the reserve
• NO_RESERVE: Item has no reserve (will sell to highest bidder)

Example: Standard Reserve Logic

• startingBid: $5,000
• reserve: $10,000

Outcomes:

• Highest bid when the item closes: $9,500 → No winner
• If someone bids $10,000 or more → Winning bid

Example:

reserveAutoBidMethod

This setting determines how max bids interact with the reserve.

Modes:

Example: MAX_BID_BELOW_RESERVE_IS_MET

• reserve: $10,000
• User places a max bid of $12,000
• Current bid is $7,500

Result:

If the user's max bid is below the reserve (e.g. $9,500), and no higher bids exist, the system may still raise the bid to $9,500 to reflect the user's full willingness — even if the reserve isn't met.

Important Notes

• reserveAutoBidMethod is set once when the sale is created and cannot be changed afterward
• The feature is only triggered through max bids (BidType = MAX)
• There is no impact on regular bidding behavior

Bid Types

In Basta, every bid is either a MaxBid or a NormalBid. These types define how the auction engine responds when bids are placed — either reactively (MaxBid) or directly (NormalBid).

MaxBid

A MaxBid allows a user to define the maximum amount they're willing to pay. The auction engine will automatically place incremental bids on their behalf until:

• They win the item
• They are outbid by a higher max bid
• Or their maximum amount is reached

MaxBid Highlights

• Bids follow the Bid Increment Table
• The winning amount may be lower than the max amount
• If outbid, the engine reacts automatically (unless max is reached)

Example: MaxBid Behavior

Bid Increment Table:

startingBid: 1000

Bid Flow:

1. User-1 places MaxBid of 5000
2. User-2 places MaxBid of 3000
3. System places a reactive bid for User-1 at 4000

Resulting State:

Example:

NormalBid

A NormalBid is a one-time bid at a specified amount. It must align with the bid increment table and does not react to counter-bids.

Example: NormalBid Behavior

Example:

Edge Cases to Know

Equal MaxBids

• If two users place identical MaxBids, the first bidder wins
• The second bid is accepted but marked as losing

MaxBid overtakes NormalBid

• If a NormalBid leads and a MaxBid is placed after, the engine will outbid it reactively, assuming the MaxBid is higher

MaxBid below Reserve

• Even if a user is winning, they must meet the item's Reserve or no winner is declared

Auction Timing

ClosingMethod

The ClosingMethod defines how and when items in a sale transition to the closing phase.

This determines whether items close individually, in sequence, or in parallel.

OVERLAPPING

This is the current active closing method used in Basta.

Each item has:

• A closingStart timestamp (defined manually)
• A closingEnd timestamp (calculated automatically)

The closingEnd is initially computed as:

If a bid is placed between closingStart and closingEnd, the countdown restarts, extending the closingEnd.

Closing Strategies with OVERLAPPING

You can configure how items begin closing:

This flexibility enables auctions to feel fast-paced or staggered based on your business needs.

Example - Simultaneous:

Example - Stacked Intervals:

ONE_BY_ONE (Coming Soon)

This method allows only one item to enter closing at a time. Items do not overlap — each must fully close before the next begins.

ClosingTimeCountdown

ClosingTimeCountdown defines the duration (in milliseconds) used to control how long an item stays in its closing phase — and how long that phase is extended when new bids are received.

Required When: closingMethod = OVERLAPPING

Any sale using the OVERLAPPING closing method must set this value.

It ensures that every item in the sale has a clear, consistent rule for how long it can stay open once it begins closing.

How It Works

When an item enters ITEM_CLOSING, its closingEnd is initialized as:

If a bid is placed after closingStart but before closingEnd, the countdown is reset:

Example

If closingTimeCountdown = 120000 (2 minutes):

Configuration

Can be set at:

• Sale level: Applies to all items in the sale
• Item level: Override for specific items

Example:

Common values:

• 30000 (30 seconds) - Fast-paced auctions
• 60000 (60 seconds) - Standard setting
• 120000 (2 minutes) - High-value items
• 300000 (5 minutes) - Premium auctions

Benefits

• Fair competition for all bidders
• Reduces sniping strategy effectiveness
• Allows true market value to emerge
• Standard practice in online timed auctions

Related Documentation

• Create Your First Auction
• Management API
• Client API

Support

Questions about auction mechanics? Contact us at hi@basta.app.