> For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://docs.ordergroove.com/llms.txt. > For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.ordergroove.com/_mcp/server. # Standard Flex Incentive Types Reference This reference guide provides a comprehensive catalog of all Standard Flex Incentive (SFI) types available in the Ordergroove platform. Each SFI type defines specific eligibility criteria that determine when an incentive should be applied. > **What are Standard Flex Incentives?** > > Standard Flex Incentives (SFIs) provide a uniform interface for creating conditional incentives. Each SFI combines eligibility criteria with incentive definitions (discounts or gifts) to create flexible, rule-based promotions. --- ## Quick Reference Table | SFI Type | Standard Name | Coupon Types | Incentive Types | Exclusive | | --------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- | ------------------ | ----------------------- | --------- | | [Product Specific](#product-specific-incentive-psi) | `PSI` | Initial, Recurring | All types | ✅ Yes | | [Prepaid Orders Per Billing](#prepaid-orders-per-billing) | `PREPAID_ORDERS_PER_BILLING` | Initial, Recurring | Discount %, Gift | ✅ Yes | | [Nth Order for Subscriber](#nth-successful-order-for-subscriber) | `NTH_ORDER_FOR_SUBSCRIBER` | Recurring only | All types | ❌ No | | [Nth Order in Cycle](#nth-successful-order-in-cycle-for-subscriber) | `NTH_ORDER_IN_CYCLE_FOR_SUBSCRIBER` | Recurring only | Discount %, Discount \$ | ❌ No | | [N Successful Items for Subscription](#n-successful-items-for-subscription) | `N_SUCCESSFUL_ITEMS_FOR_SUB` | Recurring only | All types | ❌ No | | [Item Has Subscription](#item-has-subscription) | `ITEM_HAS_SUBSCRIPTION` | Recurring only | All types | ❌ No | | [Customer Group](#customer-group) | `CUSTOMER_HAS_PRICE_CODE` | Recurring only | Discount %, Discount \$ | ❌ No | | [N Live Subscriptions for Subscriber](#n-live-subscriptions-for-subscriber) | `N_LIVE_SUBSCRIPTIONS_FOR_SUBSCRIBER` | Recurring only | All types | ❌ No | | [Item Products](#item-products) | `ITEM_PRODUCT_IN_LIST` | Recurring only | All types | ❌ No | | [Subscription Products](#subscription-products) | `SUBSCRIPTION_PRODUCT_IN_LIST` | Recurring only | All types | ❌ No | | [Buy More from Product Groups & Save More](#buy-more-from-product-groups--save-more) | `PRODUCT_GROUPS_BUY_MORE_SAVE_MORE` | Recurring only | All types | ❌ No | | [Buy More from Product Groups & Save More (Subscriptions Only)](#buy-more-from-product-groups--save-more-subscription-only) | `PRODUCT_GROUPS_BUY_MORE_SAVE_MORE_SUBSCRIPTION_ONLY` | Recurring only | All types | ❌ No | --- ## Product Specific Incentive (PSI) ### Overview Applies incentives when a product belongs to specified product groups. This is the primary way to offer different discounts for different product categories. ### Configuration **Standard Name:** `PSI` **Premise Type:** `PRODUCT_BELONGS_TO_GROUP` **Premise Value:** Array of product group names ```json ["Fruit", "Cookies", "Electronics"] ``` **Premise Operands:** N/A **Coupon Types:** Initial, Recurring **Incentive Types:** Discount Amount, Discount Percent, Gift **Exclusive:** ✅ Yes ### How It Works The system checks if the current item's product belongs to any of the specified product groups. If there's a match, the incentive applies to that item. ### Example ```json { "incentives": [ { "incentive_type": "discount_percent", "incentive_value": "10.00", "incentive_target": "item", "threshold_field": null, "threshold_value": null } ], "criteria": { "node_type": "PREMISE", "standard": "PSI", "premise_value": ["bath", "fruits"] } } ``` ### Common Use Cases * Higher discount for premium product categories * Lower discount for sale items * Category-specific promotions * Differential pricing by product type ### Important Notes * Because PSI is **exclusive**, when an item qualifies for a PSI discount, it prevents other non-exclusive item-level incentives from applying * Each product group can only appear in one PSI per coupon * If an item belongs to multiple groups with different PSIs, the system selects the best discount --- ## Prepaid Orders Per Billing ### Overview Provides incentives based on the length of prepaid subscription billing cycles. Used to reward customers who commit to longer prepaid periods. ### Configuration **Standard Name:** `PREPAID_ORDERS_PER_BILLING` **Premise Type:** `ORDER_ITEM_PREPAID_SUBSCRIPTION_ORDERS_PER_BILLING` **Premise Value:** Integer representing the number of orders per billing cycle ```json 2 // Every 2 orders ``` **Premise Operands:** N/A **Coupon Types:** Initial, Recurring **Incentive Types:** Discount Percent, Gift (Discount Amount not supported) **Exclusive:** ✅ Yes ### How It Works Evaluates the number of orders per billing cycle for prepaid subscriptions. If the subscription's billing cycle matches the premise value, the incentive applies. ### Example ```json { "incentives": [ { "incentive_type": "discount_percent", "incentive_value": "15.00", "incentive_target": "item", "threshold_field": null, "threshold_value": null } ], "criteria": { "node_type": "PREMISE", "standard": "PREPAID_ORDERS_PER_BILLING", "premise_value": 2 } } ``` ### Common Use Cases * Volume discounts for longer prepaid commitments * Tiered pricing: 3-month vs 6-month vs 12-month subscriptions * Encouraging larger upfront purchases ### Important Notes * Only applies to prepaid subscription models * Cannot use Discount Amount (only Discount Percent or Gift) * Exclusive like PSI—takes precedence over other item-level discounts --- ## Nth Successful Order for Subscriber ### Overview Triggers incentives based on the total number of successful orders a customer has completed. Includes the current order in the count. ### Configuration **Standard Name:** `NTH_ORDER_FOR_SUBSCRIBER` **Premise Type:** `NTH_SUCCESS_ORDER_OF_SUB_SUBSCRIBER` **Premise Value:** Integer ```json 5 // The 5th order ``` **Premise Operands:** * `LESS_THAN` (less than) * `LESS_THAN_OR_EQUAL` (less than or equal) * `EQUAL` (equal) * `NOT_EQUAL` (not equal) * `GREATER_THAN_OR_EQUAL` (greater than or equal) * `GREATER_THAN` (greater than) **Coupon Types:** Recurring only **Incentive Types:** Discount Percent, Discount Amount, Gift **Exclusive:** ❌ No ### How It Works Counts the cumulative number of successful orders placed by the customer across all their subscriptions. The current order is included in this count. ### Example: Exact Order Number ```json { "incentives": [ { "incentive_type": "gift", "incentive_value": "43627678400685", "incentive_target": "order" } ], "criteria": { "node_type": "PREMISE", "standard": "NTH_ORDER_FOR_SUBSCRIBER", "premise_value": 5, "premise_operand": "EQUAL" } } ``` *Customer receives a free gift on their 5th order* ### Example: First N Orders ```json { "criteria": { "node_type": "PREMISE", "standard": "NTH_ORDER_FOR_SUBSCRIBER", "premise_value": 4, "premise_operand": "LESS_THAN" } } ``` *Applies to orders 1, 2, and 3* ### Example: After N Orders ```json { "criteria": { "node_type": "PREMISE", "standard": "NTH_ORDER_FOR_SUBSCRIBER", "premise_value": 3, "premise_operand": "GREATER_THAN" } } ``` *Applies to order 4 and all subsequent orders* ### Common Use Cases * Welcome discount for first 3 orders * Loyalty reward on 10th order * Graduated discounts based on lifetime orders ### Important Notes * Counts ALL successful orders across all subscriptions for the customer * Non-exclusive, so can combine with other incentives * Current order is included in the count --- ## Nth Successful Order in Cycle for Subscriber ### Overview Similar to Nth Order for Subscriber, but operates within defined billing cycles using modulo arithmetic. Useful for recurring milestone rewards. ### Configuration **Standard Name:** `NTH_ORDER_IN_CYCLE_FOR_SUBSCRIBER` **Premise Type:** `NTH_SUCCESSFUL_ORDER_IN_CYCLE_FOR_SUBSCRIBER` **Premise Value:** Tuple of `(cycle_length, ordinal_position)` ```json [4, 0] // Every 4th order (orders 4, 8, 12, etc.) ``` **Premise Operands:** N/A **Coupon Types:** Recurring only **Incentive Types:** Discount Percent, Discount Amount, Gift **Exclusive:** ❌ No ### How It Works Uses modulo arithmetic to determine position within a cycle: * `[4, 0]` = Every 4th order (4, 8, 12, 16...) * `[4, 1]` = 1st order in every 4-order cycle (1, 5, 9, 13...) * `[4, 2]` = 2nd order in every 4-order cycle (2, 6, 10, 14...) The formula: `order_number % cycle_length == ordinal_position` ### Example ```json { "incentives": [ { "incentive_type": "discount_percent", "incentive_value": "100.00", "incentive_target": "item", "threshold_field": null, "threshold_value": null } ], "criteria": { "node_type": "PREMISE", "standard": "NTH_ORDER_IN_CYCLE_FOR_SUBSCRIBER", "premise_value": [10, 0] } } ``` *Customer gets 100% off (free) every 10th order* ### Common Use Cases * Free order every 10 orders * Bonus gift every 4 orders * Rotating rewards based on order cycles * Anniversary-style promotions ### Important Notes * Non-exclusive, can stack with other discounts * More predictable than simple Nth order for recurring rewards * Current order is included in the cycle calculation --- ## N Successful Items for Subscription ### Overview Counts the number of successful replenishment items for a specific subscription, excluding the current item. Useful for subscription-specific loyalty programs. ### Configuration **Standard Name:** `N_SUCCESSFUL_ITEMS_FOR_SUB` **Premise Type:** `N_SUCCESSFUL_REPLENISHMENT_ITEMS_FOR_SUB` **Premise Value:** Integer ```json 4 // After 4 successful replenishments ``` **Premise Operands:** * `LESS_THAN` (less than) * `LESS_THAN_OR_EQUAL` (less than or equal) * `EQUAL` (equal) * `NOT_EQUAL` (not equal) * `GREATER_THAN_OR_EQUAL` (greater than or equal) * `GREATER_THAN` (greater than) **Coupon Types:** Recurring only **Incentive Types:** Discount Percent, Discount Amount, Gift **Exclusive:** ❌ No ### How It Works Counts successful replenishment items tied to the same subscription as the current item. The current item is **excluded** from the count, so if a subscription has had 4 successful replenishments, the 5th order would be eligible for an `EQUAL` 4 condition. ### Example ```json { "incentives": [ { "incentive_type": "gift", "incentive_value": "43627678400685", "incentive_target": "order" } ], "criteria": { "node_type": "PREMISE", "standard": "N_SUCCESSFUL_ITEMS_FOR_SUB", "premise_value": 4, "premise_operand": "EQUAL" } } ``` *Customer receives a free gift on the 5th replenishment of this subscription (after 4 successful ones)* ### Common Use Cases * Free gift on 4th replenishment for a specific product * 100% off first 3 orders for new subscriptions * Graduated discounts based on subscription tenure * Product-specific loyalty rewards ### Important Notes * Counts per-subscription, not per-customer * Current item is **excluded** from count * Different from NTH_ORDER_FOR_SUBSCRIBER which counts across all subscriptions * Non-exclusive --- ## Item Has Subscription ### Overview A simple boolean check to determine if an item has an associated subscription. Primarily used to differentiate between subscription and one-time purchases. ### Configuration **Standard Name:** `ITEM_HAS_SUBSCRIPTION` **Premise Type:** `ITEM_HAS_SUBSCRIPTION` **Premise Value:** Boolean ```json true // Item must have a subscription false // Item must NOT have a subscription ``` **Premise Operands:** N/A **Coupon Types:** Recurring only **Incentive Types:** Discount Amount, Discount Percent, Gift **Exclusive:** ❌ No ### How It Works Simply checks whether the current item has an active subscription associated with it. ### Example: Subscription-Only Discount with Threshold ```json { "incentives": [ { "incentive_type": "discount_amount", "incentive_value": "5.00", "incentive_target": "order", "threshold_field": "order", "threshold_value": "50.00" } ], "criteria": { "node_type": "PREMISE", "standard": "ITEM_HAS_SUBSCRIPTION", "premise_value": true } } ``` *Order gets \$5 off if it contains at least one subscription item AND order total ≥ \$50* ### Common Use Cases * Subscription vs one-time purchase differentiation * Ensuring threshold discounts only apply to subscription orders * Gating certain promotions to subscribers only * Excluding one-time purchases from specific incentives ### Important Notes * Most commonly used with `premise_value: true` * Often combined with thresholds in the UI configuration * Non-exclusive, can combine with other incentives * In the UI, this is used behind the scenes to ensure threshold promotions only apply to subscription items --- ## Customer Group ### Overview Applies incentives when a customer has a `price_code` field ([here's how the customer price_code can be set](/reference/rest-rpc-api/customers/update)) that belongs to the specified customer groups. This is the primary way to offer different discount for different customer segments. ### Configuration **Standard Name:** `CUSTOMER_HAS_PRICE_CODE` **Premise Type:** `ORDER_CUSTOMER_IN_PRICE_CODE_LIST` **Premise Value:** Array of customer groups (price codes) ```json ["VIP", "Employees"] ``` **Premise Operands:** N/A **Coupon Types:** Recurring only **Incentive Types:** Discount Percent, Discount Amount **Exclusive:** ❌ No ### How It Works The system checks if current order's customer has a `price_code` field that matches any of the specified customer groups. ### Example ```json { "incentives": [ { "incentive_type": "discount_percent", "incentive_value": "50.00", "incentive_target": "order", "threshold_field": null, "threshold_value": null } ], "criteria": { "node_type": "PREMISE", "standard": "CUSTOMER_HAS_PRICE_CODE", "premise_value": ["VIP", "Employees"] } } ``` *Customer gets 50% off on their orders if their `price_code` is either `VIP` or `Employees`* ### Common Use Cases * Segment customers and give them a better discount: * VIP customers get 100% off discount; * Employees get 30% off while regular customers get the default 10% off; ### Importat Notes * Non-exclusive, can stack with other discounts * It is not compatible with gift incentives ## N Live Subscriptions for Subscriber ### Overview Applies incentives when the number of currently live subscriptions for a given order's customer respects its configured inequality. Useful for Subscribe More Save More retention strategies. ### Configuration **Standard Name:** `N_LIVE_SUBSCRIPTIONS_FOR_SUBSCRIBER` **Premise Type:** `ORDER_CUSTOMER_SUBSCRIPTIONS_COUNT` **Premise Value:** Non-negative Integer ```json 2 // 2 currently live subscriptions ``` **Premise Operands:** * `LESS_THAN` (less than) * `LESS_THAN_OR_EQUAL` (less than or equal) * `EQUAL` (equal) * `NOT_EQUAL` (not equal) * `GREATER_THAN_OR_EQUAL` (greater than or equal) * `GREATER_THAN` (greater than) **Coupon Types:** Recurring only **Incentive Types:** Discount Percent, Discount Amount, Gift **Exclusive:** ❌ No ### How It Works Counts the number of currently live subscriptions a given order's customer have and evaluates this number against its configured inequality. ### Example ```json { "incentives": [ { "incentive_type": "gift", "incentive_value": "43627678400685", "incentive_target": "order" } ], "criteria": { "node_type": "PREMISE", "standard": "N_LIVE_SUBSCRIPTIONS_FOR_SUBSCRIBER", "premise_value": 2, "premise_operand": "GREATER_THAN_OR_EQUAL" } } ``` *Customer receives a free gift if they have at least 2 live subscriptions* ### Common Use Cases * Subscribe More Save More ### Important Notes * Non-exclusive ## Item Products ### Overview Applies incentives when the item's product `external_product_id` field belongs to the specified list of products. ### Configuration **Standard Name:** `ITEM_PRODUCT_IN_LIST` **Premise Type:** `ITEM_PRODUCT_INTERNAL_ID_IN_PRODUCT_LIST` **Premise Value:** Array of `external_product_id` ```json ["banana", "grape", "mango"] ``` **Premise Operands:** N/A **Coupon Types:** Recurring only **Incentive Types:** Discount Percent, Discount Amount, Gift **Exclusive:** ❌ No ### How It Works The system checks if current item's product `external_product_id` field matches any of the specified `external_product_id` in the list; ### Example ```json { "incentives": [ { "incentive_type": "discount_percent", "incentive_value": "50.00", "incentive_target": "item", "threshold_field": null, "threshold_value": null } ], "criteria": { "node_type": "PREMISE", "standard": "CUSTOMER_HAS_PRICE_CODE", "premise_value": ["banana", "grape", "mango"] } } ``` \_Customer gets 50% off on their items if their item's product `external_product_id` is either `banana`, `grape` or `mango`; ### Common Use Cases * Give better discounts for specific item's products; ### Importat Notes * Non-exclusive, can stack with other discounts * The list can contain up to 25 products, configure multiple different Standard Flex Incentives or use a [Product Specific](#product-specific-incentive-psi) incentive based on product groups; ## Subscription Products ### Overview Applies incentives when the subscription's product `external_product_id` field belongs to the specified list of products. ### Configuration **Standard Name:** `SUBSCRIPTION_PRODUCT_IN_LIST` **Premise Type:** `SUB_PRODUCT_INTERNAL_ID_IN_PRODUCT_LIST` **Premise Value:** Array of `external_product_id` ```json ["banana", "grape", "mango"] ``` **Premise Operands:** N/A **Coupon Types:** Recurring only **Incentive Types:** Discount Percent, Discount Amount, Gift **Exclusive:** ❌ No ### How It Works The system checks if current subscription's product `external_product_id` field matches any of the specified `external_product_id` in the list; ### Example ```json { "incentives": [ { "incentive_type": "discount_percent", "incentive_value": "50.00", "incentive_target": "item", "threshold_field": null, "threshold_value": null } ], "criteria": { "node_type": "PREMISE", "standard": "CUSTOMER_HAS_PRICE_CODE", "premise_value": ["banana", "grape", "mango"] } } ``` \_Customer gets 50% off on their items if their subscription's product `external_product_id` is either `banana`, `grape` or `mango`; ### Common Use Cases * Give better discounts for specific subscription's products; * Give discounts based on the subscription parent product (used for Bundles and Rotating Subscriptions); * 20% off on specific box subscriptions (bundle subscriptions); * Free gift for specific rotating subscriptions; ### Importat Notes * Non-exclusive, can stack with other discounts; * It is based on the subscription product, which in some scenarios do not match the item product for the same subscription due to the usage of features such as Item SKU Swaps, Bundles or Rotating Products; * The list can contain up to 25 products, configure multiple different Standard Flex Incentives; ## Buy More from Product Groups & Save More ### Overview Applies incentives when the sum of item quantities considering only items that have their products belonging to a specific set of product groups for a given order is at least the amount configured; ### Configuration **Standard Name:** `PRODUCT_GROUPS_BUY_MORE_SAVE_MORE` **Premise Type:** `QTY_OF_ITEMS_IN_PRODUCT_GROUP` **Premise Value:** Array of exactly two elements where the first one is the minimum amount for the sum of item quantities and the second is an array of qualifiable product group names; ```json [5, ["fruits", "vegetables"]] ``` **Premise Operands:** N/A **Coupon Types:** Recurring only **Incentive Types:** Discount Percent, Discount Amount, Gift **Exclusive:** ❌ No ### How It Works The system checks if the sum of item quantities considering only items that have their products belonging to a specific set of product groups for a given order is at least the amount configured; ### Example ```json { "incentives": [ { "incentive_type": "discount_percent", "incentive_value": "20.00", "incentive_target": "order", "threshold_field": null, "threshold_value": null } ], "criteria": { "node_type": "PREMISE", "standard": "PRODUCT_GROUPS_BUY_MORE_SAVE_MORE", "premise_value": [10, ["food", "beverage"]] } } ``` \_Customer gets 20% off on their orders if the total sum of item quantities considering only the items that have their products belonging to either the `food` or `beverage` product groups is at least 10; ### Common Use Cases * The more quantities customers buy from products belonging to specific product groups, the bigger is the discount that they get; ### Importat Notes * Non-exclusive, can stack with other discounts; * It includes either Impulse Upsell and Subscription items; ## Buy More from Product Groups & Save More (Subscription Only) ### Overview Applies incentives when the sum of item quantities considering only **subscription** items that have their products belonging to a specific set of product groups for a given order is at least the amount configured; ### Configuration **Standard Name:** `PRODUCT_GROUPS_BUY_MORE_SAVE_MORE_SUBSCRIPTION_ONLY` **Premise Type:** `QTY_OF_SUBSCRIPTION_ITEMS_IN_PRODUCT_GROUP` **Premise Value:** Array of exactly two elements where the first one is the minimum amount for the sum of item quantities and the second is an array of qualifiable product group names; ```json [5, ["fruits", "vegetables"]] ``` **Premise Operands:** N/A **Coupon Types:** Recurring only **Incentive Types:** Discount Percent, Discount Amount, Gift **Exclusive:** ❌ No ### How It Works The system checks if the sum of item quantities considering **only subscription items** that have their products belonging to a specific set of product groups for a given order is at least the amount configured; ### Example ```json { "incentives": [ { "incentive_type": "discount_percent", "incentive_value": "20.00", "incentive_target": "order", "threshold_field": null, "threshold_value": null } ], "criteria": { "node_type": "PREMISE", "standard": "PRODUCT_GROUPS_BUY_MORE_SAVE_MORE_SUBSCRIPTION_ONLY", "premise_value": [10, ["food", "beverage"]] } } ``` \_Customer gets 20% off on their orders if the total sum of subscription item quantities considering only the items that have their products belonging to either the `food` or `beverage` product groups is at least 10; ### Common Use Cases * The more quantities customers subscribe to from products belonging to specific product groups, the bigger is the discount that they get; ### Importat Notes * Non-exclusive, can stack with other discounts; * It includes either Impulse Upsell and Subscription items; ## Compound Incentives ### Overview Complex incentives that combine multiple premises using logical operators (AND, OR, NOT). Currently not configurable via UI but fully supported via API. ### Configuration **Standard Name:** `COMPOUND` **Coupon Types:** Recurring only **Incentive Types:** Varies based on component incentives **Exclusive:** ❌ No ### How It Works Combines multiple simple premises using logical operators to create complex eligibility rules. The criteria is represented as a binary tree structure. ### Example: AND Condition ```json { "incentives": [ { "incentive_type": "gift", "incentive_value": "43627678400685", "incentive_target": "order" }, { "incentive_type": "discount_amount", "incentive_value": "5.00", "incentive_target": "order", "threshold_field": null, "threshold_value": null } ], "criteria": { "node_type": "AND", "children": [ { "node_type": "PREMISE", "standard": "NTH_ORDER_FOR_SUBSCRIBER", "premise_value": 5, "premise_operand": "LESS_THAN" }, { "node_type": "PREMISE", "standard": "ITEM_HAS_SUBSCRIPTION", "premise_value": true } ] } } ``` *Customer gets a free gift AND \$5 off on their 1st-4th orders, but ONLY if the order contains subscription items* ### Logical Operators * **AND**: All child premises must be true * **OR**: At least one child premise must be true * **NOT**: Inverts the child premise ### Common Use Cases * Free gift for VIPs every 3 orders * 50% off first three orders for products in specific groups * Complex eligibility rules combining customer attributes and order history * Targeted promotions with multiple qualifying criteria ### Important Notes * Not currently configurable via Self-Serve UI * Can be configured via API for custom implementations * Supports multiple incentives per SFI * More complex validation and edge cases * Non-exclusive --- ## Understanding Exclusivity ### What Makes an SFI Exclusive? Two SFI types are marked as **exclusive**: 1. Product Specific Incentive (PSI) 2. Prepaid Orders Per Billing ### Exclusivity Rules **Exclusive SFIs enforce two key restrictions:** 1. **Unique Premise Values Per Coupon** * Each premise value can only appear in one SFI of that type per coupon * Example: If "fruits" appears in one PSI, no other PSI on that coupon can include "fruits" * A second PSI with different product groups (e.g., "electronics", "books") is allowed 2. **Item-Level Discount Precedence** * If an item qualifies for an exclusive SFI discount, that SFI takes precedence over all non-exclusive item-level discounts * Other exclusive SFIs will still compete (best discount wins) * Order-level discounts can still apply * Gift incentives are always applied regardless ### Example Scenario Given these incentives: * Program-wide: 10% off all items * PSI (exclusive): 15% off fruits * Nth Order (non-exclusive): 20% off on 5th order **For a fruit item on the 5th order:** * The PSI (15% off) applies because it's exclusive * The Nth Order (20% off) is ignored even though it's higher * Only exclusive SFIs compete with each other **For a non-fruit item on the 5th order:** * The Nth Order (20% off) applies * It competes with program-wide (10% off) * Best discount wins --- ## Additional SFI Types The following SFI types are referenced in the codebase but are not currently configurable via the Self-Serve UI: * **Subscription Product Specific Incentive** - PSI variant for subscription products only * **Non-Subscription Product Specific Incentive** - PSI variant for one-time purchase products * **N Successful Items in Cycle for Subscription** - Cycle-based variant of N_SUCCESSFUL_ITEMS_FOR_SUB These may be added to the UI or made available via API in future releases. --- ## Need Help? For API details, refer to: * [Core SFI Bulk Operations Endpoint](/reference/rest-rpc-api/offer-profiles/bulk-sfi-operations) * [Offer Profile Dump Endpoint](/reference/rest-rpc-api/offer-profiles/offer-profile-dump)