Quotes

A quote is a tariff proposal that provides pricing and coverage details to a prospective customer before a policy is issued. It represents the insurer’s offer to provide coverage under specific terms and conditions, including the total premium amount for the entire contract duration, coverage period, and applicable rules. Quotes are essential in the insurance sales process, allowing customers to understand the cost and terms before committing to purchase.

Quote Definition

Quote Configuration

Quotes are configured by defining two interconnected elements that determine both coverage scope and pricing: 1. Coverage Tiers Coverage tiers define different levels of protection offered by the insurance product. Each tier represents a distinct coverage package with its own set of included perils, its eligibility rules, and its pricing engine. The platform allows the creation of custom-named tiers with no limit on the number of tiers that can be configured for a product. Tiers are typically structured in ascending order of comprehensiveness, with each higher tier providing broader protection at a correspondingly higher premium. 2. Perils Perils are the specific risks covered by the insurance policy, such as fire, theft, water damage, or liability. Each coverage tier includes a defined set of perils that determine what events are covered under that tier. The relationship between tiers and perils is fundamental: higher tiers include more perils or provide enhanced coverage for the same perils compared to lower tiers. Excess (a per-asset choice, not a tier setting) The excess (or deductible) is the amount the customer must pay out of pocket before insurance coverage applies when making a claim. Excess is not part of the tier configuration; it is an option chosen for each insured asset when the quote is prepared. Where a product offers several excess options, the customer selects the one that gives them their preferred balance between premium cost and out-of-pocket risk. Higher excess amounts result in lower premiums, while lower excess amounts increase premiums.

Pricing Engines

Each coverage tier is priced by a pricing engine. The platform supports four engine types, so that every product can be priced in the way that best fits the insurer’s rating capabilities. Spreadsheet (the most common engine) By far the most widely used engine across products. The insurer maintains a pricing spreadsheet whose logic they fill in themselves, and Korint reads the result straight from named cells — the premium, the fees, and the taxes. The broker or customer supplies the risk information, the spreadsheet computes the price using the insurer’s own formulas, and Korint returns the quote. This lets an insurer own and update its rating rules in a familiar tool, without any bespoke development, which is why most products on the platform rely on it. Manual When a product does not delegate pricing, the broker enters the quote manually — its components, amounts, and charge types. This is used where prices are agreed case by case or where no automated rating is available. Custom For an insurer with rating logic too specific for a spreadsheet, Korint can run a pricing engine coded specifically for that insurer. The rules live inside the platform and produce the premium components directly, giving full control over complex or proprietary rating while keeping quote generation instant. Mock A test engine that returns predictable sample prices. It is used to validate a product’s configuration and workflows before a real pricing engine is connected, and is never used for live quotes. Whichever engine produces the base premium, Korint then adapts it to the selected coverage tier, policy duration, and payment frequency, and adds the configured fees and taxes, so the final quote always reflects the product’s own rules.

Quote Components

Quotes are structured using components, similar to line items on an invoice. Each component represents a distinct element of the premium calculation, allowing for granular pricing transparency and flexible billing configurations. Components break down the total premium into its constituent parts, showing exactly what the customer is paying for and how each element will be billed over time. Every component in a quote has a specific type that defines its purpose. Premium components represent the base insurance coverage cost. Peril components correspond to individual risks being covered, such as theft, fire, or liability. Fee components capture administrative charges, broker commissions, or service fees. Tax components include statutory charges like Insurance Premium Tax or other regulatory levies. This structured approach ensures that every element of the premium is clearly identified and properly accounted for in billing and reconciliation. The charge type of each component determines when and how it will be billed to the customer. Recurring components are charged on every billing cycle throughout the policy period—these typically include the core premium and ongoing coverage perils. One-time components are charged only once, usually at policy inception, and might include setup fees, administrative charges, or initial processing costs. Spot components are charged at specific moments during the policy lifecycle, such as when a mid-term adjustment occurs or when a particular event triggers an additional charge. Each component contains detailed financial information including the base amount before fees and taxes, any applicable fees with their own charge types, taxes with their respective charge types, and the total amount including all fees and taxes. This comprehensive breakdown allows the system to generate accurate invoices, track revenue by component type, apply different billing schedules to different components, and provide complete transparency to customers and brokers about pricing composition.

Example 1: Complete Quote with Manual Quote

This example shows a quote for a 12-month contract. All amounts represent the total contract value.

Components

[
  {
    id: 'premium_1',
    chargeType: 'RECURRING',
    type: 'PERIL',
    premium: {
      amountPreFeesAndTaxes: 1200,  // €12.00 contract total
      totalFees: 600,               // €6.00 contract total
      totalTaxes: 240,              // €2.40 contract total
    },
  },
]

Percentages

[
  {
    componentId: 'premium_1',
    amountPropertiesFrom: ['amountPreFeesAndTaxes', 'totalTaxes'],
    id: 'fee_1',
    type: 'FEE' as const,
    chargeType: 'RECURRING' as const,
    percentage: 5,  // 5% of base amounts
  },
]

Component Formatting

[
  {
    "id": "premium_1",
    "type": "PERIL",
    "premium": {
      "fees": [
        {
          "id": "premium_1",
          "amount": 600,  // €6.00 contract total
          "chargeType": "RECURRING"
        }
      ],
      "taxes": [
        {
          "id": "premium_1",
          "amount": 240,  // €2.40 contract total
          "chargeType": "RECURRING"
        }
      ],
      "totalFees": 600,
      "totalTaxes": 240,
      "amountPreFeesAndTaxes": 1200,  // €12.00 contract total
      "amountWithFeesAndTaxes": 2040,  // €20.40 contract total
      "amountWithFeesPreTaxes": 1800   // €18.00 contract total
    },
    "chargeType": "RECURRING"
  },
  {
    "id": "fee_1",
    "type": "FEE",
    "premium": {
      "fees": [
        {
          "id": "fee_1",
          "amount": 72,  // €0.72 contract total (5% of €12.00 + €2.40)
          "chargeType": "RECURRING"
        }
      ],
      "taxes": [
        {
          "id": "fee_1",
          "amount": 0,
          "chargeType": "RECURRING"
        }
      ],
      "totalFees": 72,
      "totalTaxes": 0,
      "amountPreFeesAndTaxes": 0,
      "amountWithFeesAndTaxes": 72,  // €0.72 contract total
      "amountWithFeesPreTaxes": 72
    },
    "chargeType": "RECURRING"
  }
]

How This Will Be Billed:

Total Contract Value: €21.12 (€20.40 + €0.72)
With Monthly Billing: 12 invoices of €1.76 each
With Quarterly Billing: 4 invoices of €5.28 each
With Annual Billing: 1 invoice of €21.12

Example 2: Simple Quote priced inside the platform

A basic home insurance quote with straightforward pricing calculated entirely within the Korint platform, as a Custom or Spreadsheet engine would produce.Pricing Calculation Flow:When a broker requests a quote, the platform’s pricing engine calculates premiums based on configured rating rules:

Customer & Asset Data Collection: The broker enters property details (location, construction type, square footage, rebuild value) and customer information (claims history, security features).
Rating: The platform applies the configured rating factors:
- Base rate determined by property location and construction type
- Adjustment factors applied for security features (+10% discount for alarm system)
- Claims history modifier applied (-5% for claim-free years)
- Administrative fee added as a percentage of base premium (10%)
- Insurance Premium Tax calculated on total premium (12%)
Component Generation: The system generates a single premium component with all fees and taxes included.

Generated Quote Configuration:

{
  id: 'HOME_INSURANCE_PREMIUM',
  type: 'PREMIUM',
  chargeType: 'RECURRING',
  premium: {
    amountPreFeesAndTaxes: 600000,  // €6,000.00 (contract duration total)
    fees: [
      {
        id: 'ADMIN_FEE',
        chargeType: 'RECURRING',
        amount: 60000  // €600.00 (10% of base premium - contract total)
      }
    ],
    taxes: [
      {
        id: 'INSURANCE_TAX',
        chargeType: 'RECURRING',
        amount: 79200  // €792.00 (12% IPT on premium + fees - contract total)
      }
    ],
    totalFees: 60000,
    totalTaxes: 79200,
    amountWithFeesAndTaxes: 739200  // €7,392.00 (total contract value)
  }
}

Pricing Logic (for 12-month contract):

Base rate: €6,600.00 (for property type and location - annual)
Alarm system discount: -€660.00 (10%)
Claim-free discount: -€330.00 (5% of adjusted amount)
Subtotal: €5,610.00
Risk adjustment: +€390.00 (based on rebuild value)
Base Premium: €6,000.00 (contract total)
Admin fee: +€600.00 (10% - contract total)
Insurance tax: +€792.00 (12% of €6,600.00 - contract total)
Total Contract Value: €7,392.00

How This Will Be Billed:

Monthly billing: Customer receives 12 invoices of €616.00 each
Quarterly billing: Customer receives 4 invoices of €1,848.00 each
Annual billing: Customer receives 1 invoice of €7,392.00

Since all components are marked as RECURRING, the invoice amounts remain consistent throughout the policy period, regardless of billing frequency.Total Contract Value: €7,392.00Advantages of pricing inside the platform:

Instant quote generation (no external API latency)
Full transparency of rating factors within the platform
Easy configuration updates without external system coordination
Complete audit trail of pricing calculations

Example 3: Complex Quote with External API Integration

A comprehensive motor insurance quote with multiple perils, one-time fees, and spot charges, where base premiums are calculated by the insurer’s external pricing system and then adapted by Korint based on coverage tier, policy duration, and payment frequency.Pricing Calculation Flow with External API:When a broker requests a motor insurance quote, the platform orchestrates pricing through external API integration:

Customer & Asset Data Collection: The broker enters vehicle details (make, model, year, usage type, annual mileage) and driver information (age, license years, claims history, location).

External API Call: Korint sends a pricing request to the insurer’s external rating system:

// POST https://insurer-api.example.com/v1/pricing/motor

// Request Payload:
{
  "vehicle": {
    "make": "Renault",
    "model": "Clio",
    "year": 2020,
    "usage": "COMMUTE",
    "annualMileage": 12000
  },
  "driver": {
    "age": 35,
    "licenseYears": 15,
    "claimsHistory": [],
    "postalCode": "75001"
  },
  "coverageLevel": "COMPREHENSIVE"
}

// External API Response:
{
  "basePerils": [
    {
      "perilId": "LIABILITY",
      "annualPremium": 224520  // €2,245.20 for contract duration
    },
    {
      "perilId": "COMPREHENSIVE",
      "annualPremium": 87204   // €872.04 for contract duration
    }
  ],
  "riskScore": 0.72,
  "validUntil": "2025-10-16T09:40:06Z"
}

Korint Adaptation Layer: The platform receives the external pricing and applies product-specific configurations:
- Stores premiums for the full contract duration
- Applies tier-specific adjustments based on selected excess level
- Adds configured fees (setup fee, administrative charges)
- Calculates taxes based on jurisdiction rules
- Assigns charge types to each component (recurring, one-time, spot)

The quote stores total amounts for the contract duration. When billing, the platform divides these amounts by the number of billing periods.

Component Generation: The system structures the final quote with all components properly typed for billing.

Generated Quote Configuration:

{
  components: [
    // Recurring Peril: Liability Coverage (from external API - contract duration)
    {
      id: 'LIABILITY',
      type: 'PERIL',
      chargeType: 'RECURRING',
      premium: {
        amountPreFeesAndTaxes: 224520,  // €2,245.20 (contract duration)
        fees: [{ 
          id: 'LIABILITY_FEE', 
          chargeType: 'RECURRING', 
          amount: 56130  // 25% broker commission
        }],
        taxes: [{ 
          id: 'LIABILITY_TAX', 
          chargeType: 'RECURRING', 
          amount: 25260  // 9% insurance tax
        }],
        totalFees: 56130,
        totalTaxes: 25260,
        amountWithFeesAndTaxes: 305910  // €3,059.10 (contract total)
      }
    },
    // Recurring Peril: Comprehensive Coverage (from external API - contract duration)
    {
      id: 'COMPREHENSIVE',
      type: 'PERIL',
      chargeType: 'RECURRING',
      premium: {
        amountPreFeesAndTaxes: 87204,  // €872.04 (contract duration)
        fees: [{ 
          id: 'COMP_FEE', 
          chargeType: 'RECURRING', 
          amount: 21801  // 25% broker commission
        }],
        taxes: [{ 
          id: 'COMP_TAX', 
          chargeType: 'RECURRING', 
          amount: 9800  // 9% insurance tax
        }],
        totalFees: 21801,
        totalTaxes: 9800,
        amountWithFeesAndTaxes: 118805  // €1,188.05 (contract total)
      }
    },
    // One-Time Fee: Policy Setup (configured in Korint)
    {
      id: 'SETUP_FEE',
      type: 'FEE',
      chargeType: 'ONE_TIME',
      premium: {
        amountPreFeesAndTaxes: 0,
        fees: [{ 
          id: 'SETUP_FEE', 
          chargeType: 'ONE_TIME', 
          amount: 2500  // Platform configuration
        }],
        taxes: [],
        totalFees: 2500,
        totalTaxes: 0,
        amountWithFeesAndTaxes: 2500  // €25.00
      }
    },
    // Spot Charge: Attack Tax (triggered at policy inception)
    {
      id: 'ATTACK_TAX',
      type: 'TAX',
      chargeType: 'SPOT',
      premium: {
        amountPreFeesAndTaxes: 0,
        fees: [],
        taxes: [{ 
          id: 'ATTACK_TAX', 
          chargeType: 'SPOT', 
          amount: 560  // Regulatory requirement
        }],
        totalFees: 0,
        totalTaxes: 560,
        amountWithFeesAndTaxes: 560  // €5.60
      }
    }
  ]
}

API Integration Details:

External System: Insurer’s proprietary rating engine calculates base peril premiums using their actuarial models
Korint Processing: Receives annual amounts, converts to billing frequency, applies fees and taxes per product configuration
Audit trail: The raw request sent to the insurer and the raw response received are archived permanently against the quote, so the exact figures behind every quote can be traced later. This record is kept for traceability, not as a cache — each new quote triggers a fresh pricing request.

How This Will Be Billed:With monthly billing (12 invoices), the platform divides recurring amounts by 12:First Invoice (Policy Inception):

Liability (recurring): €254.93 (€3,059.10 ÷ 12)
Comprehensive (recurring): €99.00 (€1,188.05 ÷ 12)
Setup Fee (one-time): €25.00
Attack Tax (spot): €5.60
Total First Invoice: €384.53

Subsequent Monthly Invoices (Months 2-12):

Liability (recurring): €254.93
Comprehensive (recurring): €99.00
Total Monthly Invoice: €353.93

Billing Explanation:The quote stores total amounts for the full contract. The recurring components (liability and comprehensive) are divided equally across all billing periods. The one-time setup fee is charged only on the first invoice. The spot tax is charged at policy inception and at each contract renewal.Total Billed Over Contract: €384.53 (first month) + (€353.93 × 11 months) = €4,277.76Advantages of External API Integration:

Leverages insurer’s sophisticated actuarial models and proprietary rating logic
Maintains pricing control within insurer’s core systems
Allows real-time rate updates without Korint configuration changes
Supports complex rating factors that may be proprietary or highly specialized
Enables integration with existing insurer technology infrastructure

This structure allows the platform to bill different components on different schedules, providing flexibility for complex insurance products while maintaining complete transparency in pricing and billing.

Quote Generation

How Quotes Are Created

Quote generation begins after the customer and asset information has been entered into the system. The broker or customer first provides essential details about who is seeking insurance (the customer) and what needs to be insured (the asset). Once this foundational information is complete, the system can calculate pricing and generate one or more quote proposals. Once the customer selects their desired coverage tier and excess level, the quote generation process begins. The system evaluates the customer’s risk profile, the asset’s characteristics, and the selected coverage options against the product’s pricing rules. It then applies rating factors, calculates the base premium, adds applicable fees and taxes, and produces a complete quote with all components properly structured. This calculation happens automatically immediately after the tier selection, ensuring consistency and accuracy across all quotes.

Multiple Quote Options

For many insurance products, the platform can generate multiple quote options simultaneously, allowing customers to compare different coverage levels and pricing scenarios. Each quote option might differ in coverage limits, deductibles, optional perils included, or payment frequency. For example, a motor insurance customer might receive three quotes with different contract values:

Basic (liability-only): €600 total contract (€50/month with monthly billing)
Standard (comprehensive): €1,020 total contract (€85/month with monthly billing)
Premium (enhanced coverage): €1,440 total contract (€120/month with monthly billing)

All quotes are calculated from the same customer and asset data but reflect different coverage configurations. The system presents these multiple quotes to the customer or broker, who can review and compare them side by side. This comparison helps customers make informed decisions about the level of protection they need versus what they can afford. The broker can explain the differences between options and guide the customer toward the most appropriate choice for their circumstances.

Quote Selection and Acceptance

Once the customer reviews the available quote options, they select the one that best meets their needs. This selected quote becomes the primary quote for the policy and serves as the basis for all subsequent steps in the policy issuance process. The system records which quote was chosen and locks in that pricing and coverage configuration. When the customer accepts their chosen quote, the policy moves forward into different workflows depending on the product configuration. The quote transitions to a confirmed status, and the policy can then proceed through various processes such as the signature workflow for document signing, the payment workflow for processing the initial premium, or other product-specific workflows. Once all required workflows are completed, the policy is officially issued and coverage begins. The acceptance of a quote is a critical milestone because it represents the customer’s commitment to purchase and triggers the conversion from a pricing proposal to an active insurance contract.

Quote Lifecycle and Status Progression

A quote progresses through a defined lifecycle from initial generation through to acceptance or invalidation. Each stage represents a specific milestone in the quote’s journey and determines what actions can be performed. The system tracks the quote status to ensure proper workflow management and maintain pricing integrity. The Complete Quote Lifecycle:

Quote Generated - After the customer selects their desired coverage tier and excess level, the system calculates the pricing and generates the quote. The quote includes all premium components, fees, and taxes based on the selected configuration.
Email Sent to Customer - The system automatically sends an email to the customer presenting the quote details, including the total contract value and the per-billing-period amount based on the selected payment frequency (e.g., monthly, quarterly, annual), coverage summary, and policy terms. The customer can review this information to understand the financial commitment and coverage they will receive.
Customer Review Period - The customer reviews the quote and decides whether to proceed. During this period, several outcomes are possible:
- Customer accepts the quote - If the customer is satisfied with the pricing and coverage, they proceed to sign the policy documents and complete the purchase workflow
- Customer requests changes - If the customer wants different coverage, a different tier, or a different excess level, a new devis (quote) is created with the updated configuration. The system generates a new quote reflecting the requested changes and sends another email to the customer with the revised pricing
- Customer takes no action - The quote does not expire on its own. It stays available to accept until the broker archives it or, on products with automatic archiving enabled, until it is archived for inactivity (see Archiving Quotes).
Quote Acceptance and Policy Issuance - When the customer accepts the quote, they move forward to sign the policy documents. Once the signature and any other required workflows are completed, the policy is officially issued and coverage begins.

Pricing through the API

Three endpoints produce or change a quote, and choosing the wrong one is the most common integration mistake on this part of the journey. The difference is what they persist.

Preview a price: `POST /policies/{policyId}/calculate-quote`

Computes a premium and persists nothing. The policy is untouched: no quote is recorded, no status changes, and nothing the pricing engine computed is stored. Use it to show a price before the customer commits, to compare tiers side by side, or to answer “what if”. It accepts overrides that the persisting endpoint does not:

array

Price as though these field values applied, without writing them to the contract.

array

Price with different commission or management fees.

object

Price for a different contract duration.

array

Price only these insured items rather than the whole contract.

boolean

Return amounts prorated rather than for the full contract duration.

It also tolerates assets that have no start date yet, which the persisting endpoint does not — so it works earlier in the journey. The response carries the full result: policy and assets premium breakdowns, a breakdown shaped by the product’s price-breakdown configuration, and outputCustomFields — the values the pricing engine itself computed, such as spreadsheet outputs.

The premium sits at .policy.totalPremium in this response. Read the stored quote back from GET /policies/{policyId} and the same shape — basePrice, rates, totalPremium, components — appears at .quote.totalPremium instead. Same object, two different paths, and all amounts are integer cents.

outputCustomFields are returned but not saved. Any field the product declares as calculated is computed for the preview and then discarded. If you need those values on the contract, you must quote for real.

Commit a price: `POST /policies/{policyId}/quote`

Computes the premium and writes it to the policy, with the calculated fields alongside it. This is the call that moves the contract forward; confirmation works from the quote it stored. options is an array with one entry per asset — assetId, tier and excess are required, perils optional — and the permitted values come from the config’s quote object: quote.availableTiers, quote.availableExcesses, quote.availablePerils. The similarly named publicQuoteConfig is a smaller summary (productId, defaultTier, tiers) and is not the source of permitted values. All three calls are branch-scoped — POST /policies/{policyId}/quote?branchId=<branchId>, and likewise calculate-quote and update-policy-quote. The response body is empty. Read the stored quote back with GET /policies/{policyId}. Quoting also creates the customer’s counterpart on the payment side, which is why a setup secret requested before this call fails with PAYMENT_CUSTOMER_NOT_FOUND. Quoting is stricter than previewing: every field whose requiredFor is CREATION or QUOTE must be present across the customer, the policy and each asset, and each asset needs a start date unless the product starts cover on signature. A price that cannot be produced on underwriting grounds is recorded against the policy as a quote failure, so a refusal is an outcome to handle rather than a malformed request.

Adjust a committed price: `POST /policies/{policyId}/update-policy-quote`

Layers manual components, percentages, or manual component values on top of the quote already stored — used where a broker adds a fee or agrees a bespoke amount rather than re-running the pricing engine.

Which to call

Showing a price, comparing options, or exploring overrides → calculate-quote.
Moving the contract towards confirmation → quote.
Amending a stored quote’s components by hand → update-policy-quote.

Calling calculate-quote and then confirming fails with CONFLICTING_POLICY_STATUS: a new-business policy must be in status QUOTED to be confirmed, and only quote puts it there. A preview leaves the policy in CREATED.

Archiving Quotes

Not every quote turns into a contract. Prospects change their mind, brokers explore several scenarios in parallel, or a draft amendment becomes irrelevant. Archiving keeps the working view focused on quotes that are still being actively pursued, without losing any history. Archiving applies to work in progress: new business quotes that have not yet been signed, and draft amendments to live contracts that have not yet been applied.

Archiving a quote

A broker can archive a quote at any point before the policy is signed. Archiving closes the quote:

It can no longer be modified, accepted, or used to issue a policy.
Any pending signature request on that quote is automatically cancelled, so the customer can no longer sign an offer the broker has withdrawn.
It disappears from the active working views, keeping the broker’s portfolio focused on live opportunities.

Archived quotes are never deleted. They remain available for consultation in read-only mode, preserving the full history of what was proposed to the customer and when.

Unarchiving a quote

Archiving is not a dead end. If a prospect comes back, the broker can unarchive the quote: the platform restores it as a new working version that carries over all the information entered so far — customer details, asset information, coverage selections, and pricing work. The broker resumes exactly where they left off instead of starting from scratch. For traceability, the original archived quote stays archived; the restored version is a fresh copy that re-enters the normal quote lifecycle.

Automatic archiving

To keep portfolios clean without manual effort, the platform can archive inactive quotes automatically. Automatic archiving is configured per product with two settings:

whether automatic archiving is enabled for the product, and
the inactivity duration after which a quote is considered abandoned (for example 60 days).

Every night, the platform scans each product with automatic archiving enabled and archives the quotes and draft amendments that have had no activity for longer than the configured duration. “Activity” means any change on the quote: an edit, a new pricing request, a status change, and so on. Quotes archived automatically behave exactly like manually archived ones: they are retained, consultable, and can be unarchived at any time if the customer relationship resumes.

Automatic archiving only targets work in progress. Signed policies, active contracts, and quotes already converted into policies are never affected.

Get started

Concepts

Quote Definition

Quote Configuration

Pricing Engines

Quote Components

Quote Generation

How Quotes Are Created

Multiple Quote Options

Quote Selection and Acceptance

Quote Lifecycle and Status Progression

Pricing through the API

Preview a price: `POST /policies/{policyId}/calculate-quote`

Commit a price: `POST /policies/{policyId}/quote`

Adjust a committed price: `POST /policies/{policyId}/update-policy-quote`

Which to call

Archiving Quotes

Archiving a quote

Unarchiving a quote

Automatic archiving

​Quote Definition

​Quote Configuration

​Pricing Engines

​Quote Components

​Quote Generation

​How Quotes Are Created

​Multiple Quote Options

​Quote Selection and Acceptance

​Quote Lifecycle and Status Progression

​Pricing through the API

​Preview a price: POST /policies/{policyId}/calculate-quote

​Commit a price: POST /policies/{policyId}/quote

​Adjust a committed price: POST /policies/{policyId}/update-policy-quote

​Which to call

​Archiving Quotes

​Archiving a quote

​Unarchiving a quote

​Automatic archiving

Quote Definition

Quote Configuration

Pricing Engines

Quote Components

Quote Generation

How Quotes Are Created

Multiple Quote Options

Quote Selection and Acceptance

Quote Lifecycle and Status Progression

Pricing through the API

Preview a price: `POST /policies/{policyId}/calculate-quote`

Commit a price: `POST /policies/{policyId}/quote`

Adjust a committed price: `POST /policies/{policyId}/update-policy-quote`

Which to call

Archiving Quotes

Archiving a quote

Unarchiving a quote

Automatic archiving