Apple Foundation Models API on iOS 27: Daily Limits, Claude, and GPT

Apple's Surprise and Shine event on 9 September 2026 did not ship a new public LLM HTTP API. It shipped iPhone 18 Pro, set iOS 27 for Monday 14 September 2026, and put a billing footnote on Apple Intelligence that developers will hit as soon as they leave on-device.

The Apple Foundation Models API is the Swift LanguageModel protocol and LanguageModelSession from WWDC 2026 (8 June). iOS 27 is when that protocol reaches production phones. On-device stays free. AFM 3 Cloud, Siri AI, Image Playground, and intelligent photo editing have daily usage limits, and Apple says expanded access will be available for a fee in the future.

If the workload needs Claude or GPT-6 Astra past that cap, with a spend limit you set, that request does not go through Apple's cloud. It goes through a prepaid OpenAI-compatible gateway.

What actually shipped at Surprise and Shine #

John Ternus's first keynote was a hardware event. The developer-relevant facts are the software date and the footnote, not the cameras.

Do not write a client that assumes Apple opened /v1/chat/completions on iPhone. The public developer surface is still Swift: LanguageModelSession, on-device SystemLanguageModel, Private Cloud Compute PrivateCloudComputeLanguageModel, and vendor packages that conform to LanguageModel.

Apple Foundation Models API: three LanguageModel providers #

Apple's Foundation Models framework is a protocol, not a single model. You construct a session and call respond(to:) (or stream). Swap the model object.

On-device. SystemLanguageModel (commonly SystemLanguageModel.default) runs Apple's on-device foundation model. Apple's own developer copy: any app can use the on-device models, features work offline, and it is no cost per request. Check availability before you prompt. Context is small compared with cloud flagships. This is the right default for summarization, tagging, and short generation that can fail closed when the model is missing.

Private Cloud Compute. PrivateCloudComputeLanguageModel is the server-side path introduced for OS 27. It needs a network. Apple's 9 September footnote names AFM 3 Cloud models in Shortcuts as one of the features under daily limits. Treat PCC as the larger Apple model with a quota you do not set. Handle availability and quota errors. Do not build a product whose happy path is unbounded PCC.

Third-party packages. Anthropic ships ClaudeForFoundationModels: ClaudeLanguageModel conforms to LanguageModel, so the same LanguageModelSession API drives Claude. Google has a Gemini package in the same shape. Those packages are not Apple inference. They are vendor SDKs wearing Apple's session type. Auth, bill, and rate limits belong to Anthropic or Google unless you put a relay in front.

import FoundationModels
 
let onDevice = LanguageModelSession(model: SystemLanguageModel.default)
let local = try await onDevice.respond(to: "Tag this note in three words.")
 
if #available(iOS 27.0, *) {
  let cloud = LanguageModelSession(model: PrivateCloudComputeLanguageModel())
  let reply = try await cloud.respond(to: "Rewrite this paragraph for a commit message.")
}

APIs can still move between the OS 27 beta and the 14 September build. Trust Apple's docs over a gist.

Apple Intelligence daily limits and the future fee #

This is the line Apple added to the iPhone 18 Pro press release. Copy it; do not paraphrase the fee away:

On-device is still the free bucket. The moment the prompt needs AFM 3 Cloud, Siri AI, or Image Playground, you are on a daily cap Apple controls, and Apple has now said the overflow product is paid. No dollar amount, no iCloud+ SKU, and no per-token table appeared in that footnote.

WWDC-era reporting described higher PCC allowances on iCloud+ and free PCC for App Store small-business accounts under 2 million first-time downloads. That is June guidance, not the 9 September footnote. Budget as if cloud Apple Intelligence can throttle you, then charge you, and as if the numbers can change.

Siri AI is also age-gated (not available under 13) and region-gated (not initially in the EU on iOS). Those are product constraints, not RouterPlex constraints.

ClaudeForFoundationModels is not a RouterPlex drop-in #

Anthropic's package is the honest way to keep LanguageModelSession while calling Claude. Auth is the part people will get wrong.

import FoundationModels
import ClaudeForFoundationModels
 
// Simulator. Do not ship a bundled key.
let model = ClaudeLanguageModel(
  name: .sonnet5,
  auth: .apiKey(ProcessInfo.processInfo.environment["ANTHROPIC_API_KEY"] ?? "")
)
let session = LanguageModelSession(model: model)
let response = try await session.respond(to: "Plan a 4-day trip to Buenos Aires.")

baseURL on .proxied is the app's own Claude relay. We have not tested ClaudeLanguageModel against https://api.routerplex.com. Do not paste that host into baseURL and assume guided generation, tools, and fallbacks work. Anthropic also says a proxied relay must forward beta headers for fallbacks.

If you already have that relay, the spend-safe move is: the iOS app talks to your server; your server talks to RouterPlex (or Anthropic) with a key that never ships in the IPA.

Call GPT-6 Astra from your iOS backend #

Apple's session API does not wrap OpenAI. There is no public OpenAI Foundation Models package to cite. For GPT-6 Astra, Claude, Gemini, and the rest of a multi-vendor catalog, use the OpenAI-compatible API from a server you control.

RouterPlex base URL for the OpenAI SDK is https://api.routerplex.com/v1. The Anthropic SDK uses https://api.routerplex.com (no /v1 on the base). Model ID for Astra is gpt-6-astra.

curl https://api.routerplex.com/v1/chat/completions \
  -H "Authorization: Bearer $ROUTERPLEX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "messages": [
      {"role": "user", "content": "Rewrite this release note for App Store review."}
    ]
  }'

import os
from openai import OpenAI
 
client = OpenAI(
    api_key=os.environ["ROUTERPLEX_API_KEY"],
    base_url="https://api.routerplex.com/v1",
)
 
response = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[{"role": "user", "content": "Turn these crash logs into a one-line fix plan."}],
)
print(response.choices[0].message.content)

Keep that call on the server. An iOS client should send the user prompt to your backend; the backend attaches the RouterPlex key. The same pattern works for Claude model IDs on the Anthropic hub.

Cursor users writing the app can override the OpenAI base URL to https://api.routerplex.com/v1 so the IDE and the production backend share a catalog. That override is for Cursor, not for LanguageModelSession.

Astra still has the 272K cliff: one fat context doubles the request. A coding agent or a naive "stuff the whole thread into PCC-or-Astra" loop is how indie budgets die. Put Astra on its own key with a small cap until the first dashboard row looks right.

Prepaid budgets vs a daily cap you do not control #

Apple's cloud path is: free-ish until the daily limit, then wait, degrade, or (later) pay Apple an unpublished fee. You cannot set that limit per user of your app. You cannot put a $5 lifetime cap on Siri AI.

RouterPlex is the opposite control: you buy prepaid credit from $5, tokens bill at vendor list price with 0% markup and $0 top-up fee, the balance never goes negative, and every key has a hard spend budget. When the key hits the cap, the request stops. It does not overdraft. That is the difference between "Apple may throttle AFM 3 Cloud" and "this iOS feature cannot spend more than $5 of GPT-6 Astra."

Use on-device Foundation Models when the task fits and privacy or offline matters. Use PCC while the quota holds for Apple-quality cloud prompts. The moment you need Claude, Astra, a model Apple does not wrap, or a budget you can prove to a client, point the backend at RouterPlex.

Start a $5 RouterPlex test, put gpt-6-astra on a budgeted key, and send one live chat-completions request from your server. That is the model you can actually call on 14 September, with a cap you set.