Policy Purpose and Details

On February 20th, Onshape will begin enforcing their annual call limit policy. (A per-minute and per-day has already existed.) This policy is designed to further reduce PTC's AWS server costs associated with hosting Onshape.

The limit depends on the subscription, but most notably:

• 5,000 per user for Professional subscriptions
• 10,000 per user for Enterprise subscriptions

Beyond this, API calls must be purchased.

Notable exceptions include:

• Publicly available apps in the Onshape app store
• FeatureScripts contained in your Onshape models
  • This is because the call comes from Onshape's server and not a separate server
• Webhook notifications

Lastly, although certain API calls are likely more expensive than others, Onshape is currently treating all API calls as equally expensive for simplicity.

Tips and Tricks for Developers

Savvy Onshape developers will be rewarded. Unsavvy ones will be punished. If you have a private Onshape app, be sure to rewrite portions of your code that make unnecessary API calls. For example:

• Make a call once and then cache retrieved information for later use rather than repeating calls.
• Avoid API calls in "simple" loops that run on every assembly part, configuration, custom property, etc.
• Be careful with event-driven calls or timed calls that will automatically update the data in your app.
  • Instead, give the user the ability to update your app with recent changes to their model.
• Use client messaging rather than API calls to obtain user selections in the model.
  • This gives developers a way to attach to Onshape selections by subscribing to native message events in the browser. More specifically, these are HTML specifications for events that can be fired with JavaScript (including languages and frameworks that compile to JS, like TypeScript, Razor, and Blazor).
• Warn users that API usage might be high if they run a function on large or complex models.
• Look for "efficient" API calls that collect all of the data you need instead of just some of the data you need.
  • See the next section for examples.

Examples of "Efficient" API Calls

The following are examples of API calls that might be inefficient in certain scenarios.

• Getting BOM data for each sub-assembly versus the entire assembly using Assembly/getBillOfMaterials
  • Inefficient: Setting multiLevel equal to false
  • Efficient: Setting multiLevel equal to true
• Getting a part's body details by querying individual parts versus an entire part studio
  • Inefficient: GET /parts/d////e//partid//bodydetails
  • Efficient: GET /partstudios/d////e//bodydetails
• Getting a part's tessellation data by querying individual parts versus an entire part studio
  • Inefficient: GET /parts/d////e//partid//tessellatedfaces
  • Efficient: GET /partstudios/d////e//tessellatedfaces
• Getting the metadata for a part versus all parts in a document
  • Inefficient: GET /metadata/d////e///
  • Efficient: GET /metadata/d////e//p
• Getting the data for a specific revision in a document versus all revisions in a document
  • Inefficient: GET /revisions/c//partnumber/
  • Efficient: GET /revisions/d/
• Getting all sketch information for a sketch, including its bounding box, versus only its bounding box
  • Inefficient: GET /partstudios/d////e//sketches//boundingboxes
  • Efficient: GET /partstudios/d////e//sketches
• Getting a part's shaded views by querying individual parts versus an entire part studio
  • Inefficient: GET /parts/d////e//partid//shadedviews
  • Efficient: GET /partstudios/d////e//shadedviews

Don't Guess – Hire the Best

Imagine writing an app yourself or hiring someone to write you app, making that app a key part of your team's workflow, and then it stops working halfway through the year in because your company's API call limit has been reached. That's what you can expect from unseasoned developers.

On the other hand, if you want expert Onshape developers who can navigate around such pitfalls, contact us to discuss your project. Alternatively, if you're interested in developing FeatureScripts yourself, check out the world's only zero-to-hero FeatureScript training course.

2025

FeatureScript: A Year of New Standard Capabilities

2025 was a massive year for the FeatureScript Standard Library. Onshape didn’t just improve existing tools; they introduced entirely new classes of modeling capabilities. The addition of Sheet Metal Forms (1.193) and Routing Curves (1.195) opened up new domains for programmatic geometry creation.

For developers building custom features, the New Query Variable (1.203) is a game-changer, allowing any user to “parametrically create selection”—enabling features that can intelligently select geometry created during the feature’s execution. Diagnostics also got a boost with custom message support for reportFeatureWarning (1.207), allowing developers to write cleaner, more informative error states.

API: Drawings, Webhooks, and Direct Translation

2025 was defined by closing the gap between the UI and the API, specifically in Drawings and Data Translation. Developers gained the ability to manipulate Drawing Views (1.203), Centermarks (1.203), and Surface Finish Symbols (1.200).

Crucially, this year saw the introduction of API Versions V11 and V12, bringing stricter typing and new capabilities. The new Direct Translation Endpoints (1.199) and Asynchronous STEP Export (1.198) streamlined how external applications extract geometry. On the integration side, the long-awaited Document Sharing Webhook (1.202) finally arrived, allowing apps to react instantly when access permissions change.

See the following change log summaries for Onshape’s FeatureScript and REST API:

FeatureScript Change Log Summary 2025

See Onshape’s general change log here: https://www.onshape.com/en/changelog/

• Query Variables: New Parametric Create Selection query variable type. setQueryVariable (1.203)
• Diagnostics: Support for custom messages in reportFeatureWarning (1.207)
• Sheet Metal Forms: New Standard Library features for sheetMetalFormed (1.193)
• Routing Curves: New routingCurve capabilities for 3D wires and tubing (1.195)
• Constrained Surfaces: New capabilities for creating surfaces from meshes or point clouds: constrainedSurface (1.195)
• Replace Face: Updated replaceFace to support multiple face selections (1.198)
• Wrap: Enhanced opWrap feature to support conical faces (1.194)
• Cosmetic Threads: New programmatic support for  cosmeticThread (1.195)
• Performance: Improvements to FeatureScript editing logic and execution. (1.206)
  Note: even though this was improved, I’ve noticed some performance hits in this area regarding custom features. Some custom features no longer function as originally intended.

API Change Log Summary 2025

See Onshape’s API change log here: https://onshape-public.github.io/docs/changelog/

• Drawings – Views: Support for creating and editing standard views (1.203)
• Drawings – Annotations: Create/Edit Centermarks, Surface Finish Symbols, Chamfer Dimensions, and Datums (1.193 – 1.203)
• Drawings – Geometry: Support for creating Sketches within Drawings (1.200)
• Webhooks: New onshape.document.lifecycle.shared event for sharing/unsharing (1.202)
• API Versioning: Introduction of API V11 and V12 with stricter element type checking (1.199, 1.201)
• App Elements: New endpoint for subelements and improved JSON tree diffing (1.197, 1.206)
• Direct Translation: Export Assemblies/Part Studios directly to glTF, OBJ, SOLIDWORKS, and STEP (1.199)
• Async Export: New Asynchronous STEP export endpoint (1.198)
• Items & Content: New endpoints for Items (1.198) and Standard Content (1.205)
• Workflow: Lightweight endpoint for release package status (1.200)
• Configurations: New visibilityCondition attribute for configuration parameters (1.192)
• Global Permissions: Endpoints to manage Enterprise global permissions (1.201)

Want to keep up with future CADSharp.com content and training events? Join our newsletter!