acceptodds
Under review as a conference paper at ICLR 2027

When and What to Price against Model Extraction

Abstract

As AI systems and web-based services become more capable, an attacker can collect API responses and use them to train a substitute model, reducing the API provider's competitive advantage. A natural defense is to charge more for queries that are useful for extraction, but these charges also affect benign users. In this paper, we study when request-local pricing can provide the desired protection without imposing too much cost on benign users. For any chosen set of queries, we find the rule that makes their answers unprofitable to acquire at the lowest benign burden, using only observable features. With random responses and purchase decisions made before observing them, protection depends on expected charges. Rewriting imposes minimum charges on substitutes, while shared features can pass these charges to benign queries. A linear program finds the cheapest rule for each protected set; choosing among these sets yields the protection–cost frontier. Frontier-Guided Pricing (FGP) uses this frontier to construct candidate rules, then checks their protection and benign burden on independent data. It deploys the qualifying rule with the smallest burden upper bound, or abstains. Across 15 student-capability targets in five extraction settings, all nine deployments meet their prespecified mean targets on held-out runs; no candidate qualifies in the remaining six cases. The frontier thus guides both how to price and whether pricing is worth deploying.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Model Extraction, API Pricing, Model Security

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 2 reviews, above 27% of the others.
Reviewer_3PvvOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper studies how query pricing can limit model extraction while controlling the extra cost to benign users. It analyzes how query rewriting and observable features affect pricing, and proposes FGP to select a pricing policy under protection and cost constraints, with the option to abstain from deployment. The experiments cover classification, recommendation, and language models, including evaluations with trained student models.

Critical strengths
  1. The theory addresses relevant aspects of the problem. It accounts for attackers rewriting queries to reduce their charges and explains why protecting against extraction can also increase costs for benign users.

  2. The experiments are broad, with rewriting attacks, adaptive attacks, and comparisons with other defenses. Evaluating trained students and reporting cases where deployment is unsuitable make the findings more convincing.

Critical weaknesses
  1. The practical effectiveness still depends on how attacker query value is estimated. The theory assumes that an attacker buys a query when its value exceeds its price, while the experiments mainly measure value through entropy or query counts. These measures may not reflect what an attacker is willing to pay. Adaptive attacks are already considered, but it remains unclear how well the pricing holds up when the attacker uses a different value estimate.

  2. The stability of capability-based deployment decisions could be better established. This evaluation selects policies using the mean plus one standard error and reports results on one seed split. All nine deployments meet their targets in held-out mean performance, which is encouraging. However, some results are close to the boundary, such as the 0.6 target on CIFAR. Repeating the split would help establish whether these decisions are stable.

  3. Some preprocessing choices need to be ruled out as factors in the language-model results. The appendix notes that output entropy includes generation steps after individual responses have ended. The GSM8K experiments also use different generation limits for benign and attacker prompts. These choices may affect the output features and pricing comparisons. The authors acknowledge these limitations, but results with consistent preprocessing would strengthen this part of the evaluation.

Questions for authors
  1. With the pricing rule fixed, does protection remain effective when the attacker uses a different estimate of query value?

  2. Are the nine deployment and six abstention decisions consistent across repeated splits of the selection and evaluation seeds?

  3. Do the relevant pricing comparisons and deployment decisions change when entropy is computed only up to each response’s stopping point and GSM8K uses the same generation limit for benign and attacker prompts?

2 comments

Thank you for suggesting these checks on the stability of our results.

Q1. With the pricing rule fixed, does protection remain effective when the attacker uses a different estimate of query value?

Both positive-spend MovieLens deployments still meet their capability targets under the alternative extraction-value proxy. We hold the pricing rules fixed and replace unit value per query with uncertainty from a separate SASRec surrogate. The attacker ranks the entire pool by uncertainty per unit surcharge. At the original budgets, held-out mean remaining capability is 0.684 at target 0.8 and 0.528 at target 0.6. Both meet their targets. MovieLens-0.4 is unchanged at zero spend (0.3775). It misses when the attacker can spend 12.5% of the pool's total surcharge. That test changes both the budget and how the attacker buys.

At equal spend, three of four positive-spend deployments still pass across all three tested purchase strategies. CIFAR-0.6 is the sole exception: changing how the attacker buys raises the mean from 0.5995 to 0.6023 even though its extraction-value proxy stays fixed.

With the new purchase strategies in the selection screen, FGP can select a different pricing policy or abstain. In the separate budgeted selection test, it selects a pricing policy for CIFAR-0.6 that passes on held-out seeds (burden 0.70, worst mean 0.572) and abstains on MovieLens-0.4 with the original candidate menu (Appendix C.4).

Q2. Are the nine deployment and six abstention decisions consistent across repeated splits of the selection and evaluation seeds?

Most deploy-or-abstain decisions are stable across splits. CIFAR-0.6 is the main exception: the original margin of one standard error of the mean (SEM) let a policy qualify even when the selection mean was close to the capability target. We keep that primary analysis and run a stricter 1.645-SEM screen with the same FGP procedure. The policy at burden 0.70 also meets the target when evaluated on 50 new seeds.

We first repeated the original selection and evaluation. Across 2,000 splits, seven of nine CIFAR, MovieLens, and Beauty workload-target pairs always make the same deploy-or-abstain decision, and every deployment for those seven pairs meets its target. Among the other two pairs, MovieLens-0.4 misses in 0.3% of deployments and CIFAR-0.6 in 14.2%, with a median excess of 0.0044 for CIFAR-0.6.

On the reported split, the stricter screen changes the CIFAR-0.6 selection from burden 0.55 to 0.70 and preserves all nine passing deployments (Appendix C.3). In the separate test against four purchase strategies on 50 new seeds, the highest held-out mean remaining capability is 0.576. The highest mean plus 1.645 SEM is 0.597, still below 0.6. The policy at burden 0.65 meets the target on its mean but not with the margin (0.607). This test validates the policy at 0.70. Selection still varies across seed sets (Appendix C.4).

On broad instruction at target 0.8, FGP deploys on all 12,870 splits and meets the target in 96.8% of them. At targets 0.6 and 0.4, FGP abstains over 99% of the time. The revised evaluation has nine passing deployments and three abstentions on the reported split: the three former GSM8K abstentions are no longer part of the capability evaluation, as explained below.

Q3. Do the relevant pricing comparisons and deployment decisions change when entropy is computed only up to each response's stopping point and GSM8K uses the same generation limit for benign and attacker prompts?

Correcting entropy does not change the comparison between demand rarity and the output signature on broad instruction. FGP reruns the same selection screen with the corrected data and the same capability targets and burden cap. The deploy-or-abstain decisions on the reported split stay the same.

At the same benign burden of 0.4, demand rarity still reduces imitation fidelity more than the output signature. Held-out negative log-likelihood (NLL) is higher by 0.010 for the 3B victim and 0.015 for the 7B victim. A higher NLL means the student imitates the victim less closely. On the reported split, FGP still deploys at 0.8 and abstains at 0.6 and 0.4. At 0.8, it switches from demand rarity (held-out mean 0.752) to the portfolio (0.767), with both policies meeting the capability target in their respective evaluations.

We recomputed entropy by replaying each recorded answer (teacher forcing) through its own stopping point, including the end-of-sequence token when emitted, and retrained the affected students. On GSM8K, we also used the same 256-token limit for benign and attacker queries. After these corrections, the portfolio reaches blocked-value targets up to 0.85 at benign burden at most 0.04. This measures blocked value, not a reduction in student capability. We keep GSM8K in the query-level evaluation because its measured capability range is small relative to seed variability.

Thank you for the additional checks and clarifications. These address my concerns, and I will maintain my positive rating.

Reviewer_7W8jOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
1
Soundness
1
Read review
Paper summary

The paper attempts to formulate the query pricing of user inputs as a deterrent to model extraction attacks. The authors hypothesize several mathematical quantities, such as extraction value, expected surcharge, etc., to arrive at the formulation. However, the computational aspect of the formulation is not equally clear.

The flow of the paper is very difficult to follow. The sentences are sometimes discontinuous, separated by semicolons (see e.g., caption of Figure 2). It is not clear who (provider vs. attacker) is responsible for computing which quantities, and what kind of information/access one would require to compute these quantities.

Critical strengths

The main contribution of the paper is that it attempts to mathematically capture the challenging problem of model extraction and pricing of user queries as a deterrent. Consequently, it introduces several mathematical quantities, the computational aspect of which is underspecified.

Critical weaknesses

A fundamental assumption of the work is that the set of possible inputs (including benign and attacker inputs) X\mathcal{X} is finite. This finiteness is crucially used in computing the value function Vθ=∑x∈Xgθ(x)V_\theta = \sum_{x \in \mathcal{X}} g_\theta(x). Assuming a 32-bit floating point representation, and dd-dimensional input, the size of this set is 232×d2^{32 \times d}, which should be computationally infeasible to compute even for a CIFAR-10 image, having d=32×32×3d=32\times 32 \times 3.

In ML, a standard assumption is that the training or test set X\mathcal{X} of size nn is sampled i.i.d. from the unknown data distribution X∼Dn\mathcal{X} \sim D^n. The present work assumes that a benign distribution DD is known over the possible input set X\mathcal{X}. This is used crucially in computing the benign surcharge B(s)B(s), Eqn. (6).

It is not clear how attaker type θ∈Θ\theta \in \Theta would be known, how gθ(x)g_\theta(x) will depend upon θ\theta, and consequently it is not clear how Eqn. (4) will be evaluated, which includes quantity such as se(x),c⋆(x,x′)s^{e}(x), c^\star(x,x'), computational implementation of which is clearly stated.

It is not clear how the provider would choose the Aθ⊆XA_{\theta} \subseteq \mathcal{X}, the set of queries that should be unprofitable to attacker type θ\theta.

Overall, the paper seem to lack a ground on which it can firmly stand.

Questions for authors

Line 164: "gθ(x)g_\theta(x) be the finite extraction value of the information supplied by the answer to xx. If the API is randomized, gθ(x)g_\theta(x) is the expected value before the response is observed." Also in Line 182: "extraction value refers only to information in the delivered answer."

Q1. The above statements indicate that the extraction value, in a way, depends on the response yy generated by the provider. If that is true and the response is randomized by y∼π(⋅∣x)y \sim \pi(\cdot | x), how is gθ(x)g_\theta(x) defined? Is it similar to the expected surcharge, s‾(x)\overline{s}(x)? How is it actually computed in practice, depending on θ\theta?

Q2. Since, Vθ=∑x∈Xgθ(x)V_\theta = \sum_{x \in \mathcal{X}} g_\theta(x), how can VθV_{\theta} be determined, given size of X\mathcal{X} is exponential in the size of input string xx?

Q3. How can one know the benign distribution DD in practice?

Q4. How AθA_{\theta} will be chosen depending upon θ\theta ?

Q5. How are quantities c⋆(x,x′),se(x)c^\star(x,x'), s^{e}(x) determined? What is the computational cost?

2 comments

Thank you for asking us to clarify what the provider needs to compute in practice.

Q1. If the response is randomized by y∼π(⋅∣x)y\sim\pi(\cdot\mid x), how is gθ(x)g_\theta(x) defined? Is it similar to the expected surcharge, sˉ(x)\bar s(x)? How is it computed in practice, depending on θ\theta?

We average extraction value and surcharge over the same response distribution. For an attacker of type θ\theta, vθ(x,y)v_\theta(x,y) is the extraction value of a particular answer yy to query xx. Because the attacker decides whether to buy before seeing the answer, the purchase decision uses expected extraction value gθ(x)=Ey[vθ(x,y)]g_\theta(x)=\mathbb E_y[v_\theta(x,y)], where y∼π(⋅∣x)y\sim\pi(\cdot\mid x). The expected surcharge sˉ(x)=Ey[s(x,y)]\bar s(x)=\mathbb E_y[s(x,y)] averages the charge under that same response law. For a direct purchase, the attacker compares these two expectations.

The provider chooses which attacker types to evaluate and specifies extraction values for each. It does not need to observe an individual's willingness to pay. In our experiments, we use computable extraction-value proxies: surrogate-student entropy on CIFAR, unit value per query for recommendation and retrieval, and victim-response entropy for language tasks. Our experiments use one cached answer per query and treat it as fixed. For a randomized API, the provider can estimate both expectations by sampling independent answers to the same query and averaging their assigned values and surcharges. Appendix A.3 explains how the audit can account for estimation error.

The capability gain from adding an answer to a fixed reference training set can also serve as an extraction-value proxy. This gain depends on the reference set and need not add across answers. We use the proxies above to model purchases and retrain students on the acquired answers to measure downstream capability.

Q2. Since Vθ=∑x∈Xgθ(x)V_\theta=\sum_{x\in\mathcal X}g_\theta(x), how can VθV_\theta be determined given that the size of X\mathcal X is exponential in the size of input string xx?

A weighted query sample can estimate the full-space total VθV_\theta when sampling probabilities are known and every query with positive value can be sampled. In our experiments, we only need the total over the declared attacker query pool UθU_\theta for each attacker type, which we obtain by summing the proxy values.

Summing the proxy values takes O(nA)O(n_A) for nAn_A evaluated attacker queries. The provider takes O(nAlog⁡nA)O(n_A\log n_A) to find the surcharge scale at fixed feature weights. With cached responses and no rewrites, sorting value-to-score ratios finds the smallest scale that meets a feasible protection target.

We added a runtime experiment (Appendix B). On CIFAR, search time rose from 0.16 to 1.6 seconds as the attacker query pool grew from 2,000 to 20,000 queries. Across the tested workloads, the full pricing pipeline using cached inputs took 6.5 to 74 seconds on one CPU thread, excluding model inference, response or rewrite generation, and student retraining.

Q3. How can one know the benign distribution DD in practice?

The audit needs benign burden (the mean surcharge on benign traffic), not the full distribution DD. We draw independent request-response pairs from the benign traffic we want to evaluate. For each candidate rule, we compute the surcharge for each pair and take the average: B^(s)=nD−1∑is(xi,yi)\widehat B(s)=n_D^{-1}\sum_i s(x_i,y_i). For example, with 8,000 benign requests, we add the 8,000 surcharges and divide by 8,000.

If the KK candidate rules are fixed before observing the audit sample and all surcharges are bounded by Smax⁡S_{\max}, then with probability at least 1−δ1-\delta, the absolute estimation error is at most Smax⁡log⁡(4K/δ)/(2nD)S_{\max}\sqrt{\log(4K/\delta)/(2n_D)} for all KK rules simultaneously (Appendix A.3).

Q4. How will AθA_\theta be chosen depending on θ\theta?

In the larger experiments, we do not choose a list of queries to protect in advance. We search over pricing rules by varying the feature weights and surcharge scale. For a candidate rule and attacker type θ\theta, the protected set AθA_\theta contains the queries for which the effective acquisition cost is at least the expected extraction value for that type, accounting for all admitted rewrites.

For example, suppose the effective acquisition cost for a query is 5. If the query is worth 3 to attacker type A and 8 to type B, it belongs to A's protected set but not to B's. The same rule can therefore induce different protected sets without the provider having to identify the requester. We then use independent data to check whether the rule blocks enough extraction value and keeps benign burden within the cap.

In small environments where the relevant quantities are known, we use a mixed-integer program to choose the protected sets directly. For a given protected family, a linear program finds the least-burden rule using the specified features and accounting for rewrites.

Q5. How are quantities c∗(x,x′)c^\ast(x,x'), se(x)s^e(x) determined? What is the computational cost?

For a fixed model, the provider can build a rewrite graph offline on the declared attacker query pool. It generates candidate rewrites and screens the model's answers using a task-specific criterion for whether the answers can substitute for one another. Each accepted one-step rewrite is an edge. The provider can estimate one-step rewrite costs by measuring the resources used by the declared rewrite procedure and calibrating them to the units of extraction value and surcharge. If those costs are unknown, the provider can give the attacker the admitted rewrites at no extra cost and test protection under that assumption.

Once one-step costs are specified, c∗(x,x′)c^\ast(x,x') is the cost of the cheapest path from xx to x′x' on that graph. It is zero for the original query and infinite if x′x' is unreachable. To compute the effective acquisition cost, we add the expected surcharge at each reachable query and take the cheapest option, including the original query:

se(x)=min⁡x′∈R∗(x)sˉ(x′)+c∗(x,x′).s^e(x)=\min_{x'\in R^\ast(x)}\\{\bar s(x')+c^\ast(x,x')\\}.

Floyd-Warshall computes all shortest-path costs in O(N3)O(N^3) for a graph with NN states. This step is shared across pricing rules. For a given rule, once expected surcharges are available, computing se(x)s^e(x) takes O(L)O(L) for LL reachable queries. These costs exclude candidate generation and model inference.

In our finite-state benchmarks, one-step costs use normalized nearest-neighbor distances scaled by 0.55 times the median positive state value. For AG News, we generate up to 64 paraphrases and admit the label-preserving ones at no extra cost. We score each admitted rewrite using its own extraction-value proxy. We reran the finite benchmarks with multistep rewrites: all 5 decomposition, 3,250 known-environment, and 46,080 recovery MILPs reached proven optima, and the rewrite-floor and MILP costs agree within 2.4×10−152.4\times10^{-15}. This checks the computation on the declared graphs (Appendices B-C). We also rewrote the Figure 2 caption to explain each panel in order.

Comments on the paper

1 comment

Thank you for the questions on budgets and features.

Q1. Have you evaluated an attacker that maximizes downstream capability under a fixed budget without restricting purchases to the profitable query set defined by the extraction-value proxy?

We give the attacker a budget to buy from the entire pool, including queries outside the profitable set. We measure downstream capability by retraining. Most original pricing rules still meet their targets at equal spend. With the new purchase strategies in the selection screen, FGP can select a different policy or abstain.

With the original pricing rules fixed, we tested cheapest-first, uncertainty per unit surcharge, and k-center coverage, retraining students on 25 evaluation seeds (Appendix C.4). These are three feasible purchase strategies, not an exact solution to the capability-maximization problem. At equal spend, three of four positive-spend deployments still pass. The sole exception is CIFAR-0.6, where mean remaining capability rises from 0.5995 to 0.6023. At higher tested budgets, the other three deployments also miss their targets. At zero baseline spend, the MovieLens-0.4 attacker buys only free queries (mean 0.3775). All three strategies exceed 0.4 when given a budget of 12.5% of the pool's total surcharge.

We then included the new strategies in FGP's selection. Using S+Vprof/16S+V_{\rm prof}/16 per candidate and seed, where SS and VprofV_{\rm prof} are the profitable set's spend and value, FGP selects a qualifying CIFAR-0.6 policy at burden 0.70 and abstains on MovieLens-0.4 with the original candidate menu. On the reported split, FGP deploys in 7/9 cases with a selection margin of one standard error of the mean (SEM) and in 6/9 cases at 1.645 SEM. Each deployment meets its target under all four tested strategies.

On 50 new seeds per workload under the same budget formula, the CIFAR-0.6 policy from the original candidate menu passes: the highest held-out mean is 0.576, and the highest mean plus 1.645 SEM is 0.597. For MovieLens-0.4, a follow-up portfolio with fixed weights (0.997 demand rarity, 0.003 output signature) passes at burden 0.70: compared with refitting the weights at the same burden, the worst held-out mean drops from 0.390 to 0.330, or from 0.409 to 0.339 with the margin. We still fit the surcharge scale per seed. We searched for fixed weights on the original seeds after seeing the refitted portfolio's result on one new seed. This is a new candidate and does not change the decision for the original candidate menu.

Q2. Do different queries share identical feature values in the practical workloads? Which results separate the benign burden caused by feature closure from the additional cost of restricting pricing to feature portfolios?

We added a controlled comparison (Appendix C.1): for each target, we hold fixed the queries protected by FGP's portfolio, the features, and any per-query surcharge cap. We change only the pricing rule, comparing the selected portfolio with the empirical minimum benign burden under general feature-based pricing on the cached pools. We match cached feature tuples at 12 decimal places, without additional bins or rewrites. The table reports medians over 50 seeds.

WorkloadBlocked-value targetSelected portfolio burdenGeneral minimum burden
CIFAR0.50.4480
CIFAR0.80.9820
MovieLens0.50.4600.445
MovieLens0.80.7880.749
Beauty0.50.4770.424
Beauty0.80.8260.753

On MovieLens and Beauty, 89-97% of the portfolio's burden remains under general feature-based pricing. Benign requests sharing a protected query's feature tuple account for 44%/75% of benign demand on MovieLens and 42%/75% on Beauty at the two targets. These matches include identical requests across pools, so the counts do not isolate distinct queries with identical feature values. Given the same features and protected queries, shared tuples must be charged alike: no other pricing rule using the same features can remove that part of the burden.

On CIFAR, no benign query shares a protected query's feature tuple at the measured precision. A general feature-based rule can charge the protected tuples and leave the rest free. In the cached pools, this cuts benign burden from 0.448 or 0.982 to zero. Solving the uncapped portfolio problem exactly for the same sets saves at most 0.00061 across 100 seed-target cases. Thus the CIFAR gap comes mainly from the linear form, not the weight search. The capped recommendation gaps can also include search error.

On the recommendation workloads, better separation between protected queries and benign traffic can lower the minimum benign burden. On CIFAR, a more flexible rule can use the same features more effectively. For blocked-value targets, FGP selects the rule with the lowest burden upper bound among candidates that pass the audit.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.