- Exam Format and Logistics at a Glance
- Fee, Retake and Validity Rules
- The 15 Exam Objectives, Condensed
- Object Model Quick Reference
- Sketches, Dimensions and Features
- Selection, Traversal and Component States
- Drawings, Views, BOMs and Saving
- Troubleshooting Checklist
- Mapping Objectives to a Prep Calendar
- What the Exam Is Not
- Frequently Asked Questions
- The exam has 28 questions: 18 hands-on automation tasks and 10 multiple-choice, worth 100 points total.
- You need 70 points to pass, and you get 120 minutes with no pause option.
- The exam targets Visual Basic for Applications (VBA), not C# add-ins or PDM API work.
- The US$49 fee covers one North American attempt; a retake needs a new credit and a 14-day wait.
Exam Format and Logistics at a Glance
The Certified SOLIDWORKS Professional API (CSWP-API) credential is issued by SOLIDWORKS, part of Dassault Systemes, and it tests whether you can automate SOLIDWORKS through code. Unlike many certifications, it is mostly practical: 18 of the 28 questions are hands-on automation tasks, and the remaining 10 are multiple-choice. The whole exam is scored out of 100 points, and 70 points are required to pass.
| Item | Fact |
|---|---|
| Credential | SOLIDWORKS API Professional (CSWP-API) |
| Issuer | SOLIDWORKS, Dassault Systemes |
| Questions | 28 total: 18 hands-on tasks + 10 multiple-choice |
| Total points / passing | 100 points / 70 points (70%) |
| Duration | 120 minutes (two hours), cannot be paused |
| Language focus | Visual Basic for Applications (VBA) |
| Delivery | Non-proctored online, via Tangix/VirtualTester |
| Your setup | Your own working commercial or student SOLIDWORKS, SOLIDWORKS 2017 or later, plus your own Internet connection |
| Prior certification | None required |
Two details deserve emphasis. First, the exam runs in the VirtualTester Web Client, and the current browser-client and recovery instructions take precedence over the legacy TesterPRO installation and crash language you may see in older copies of the exam guide. Read the current exam procedure document before test day rather than relying on forum memories. Second, "2017 or later" is a software minimum, not an exam-version label; the live exam page and sample guide are undated.
Fee, Retake and Validity Rules
- Fee: US$49 for one North American attempt. This excludes software and training costs. Full breakdown in the CSWP-API certification cost guide.
- Retakes: A retake requires a new CSWP-API credit and a wait of at least 14 days.
- No pausing: Once you start, the clock runs. Plan an uninterrupted two-hour block.
- Prerequisites: None for admission. SOLIDWORKS Design Essentials and API Fundamentals are recommended preparation, but training courses are not exam admission requirements. See CSWP-API requirements for the full eligibility picture.
- Validity: The issuer's 2020 Certification Program Q&A states that customer and student certifications do not expire.
- Passing grade: 70%. That is a cut score, not a pass rate; published population pass rates were not verified. See what you need to pass and what the pass-rate data does and does not show.
The 15 Exam Objectives, Condensed
The issuer lists 15 exam objectives, unweighted, and explicitly describes the task list as non-exhaustive. No percentage weights are published, so treat every objective as fair game. Some headings overlap, particularly around drawings; they are retained here as the issuer wrote them. For a deeper walkthrough, read the complete guide to all 15 content areas.
- Understanding the API Object Model
- Troubleshooting
- Part design automation
- Drawing Automation
- Assembly automation
- Adding sketch entities and dimensions
- Feature creations such as extrudes and cuts
- Selection and traversal techniques
- Hide/Suppress/Resolve components
- Creation of drawings
- Insert drawing views
- Insert a BOM
- Save drawings in different file formats
- Add custom properties
- Save and close documents
Object Model Quick Reference
Domain 1: Understanding the API Object Model
Everything in the SOLIDWORKS API hangs off a hierarchy of objects. The exam expects you to navigate it without guessing.
- SldWorks is the application root; it opens documents, creates new ones and returns the active document.
- ModelDoc2 is the generic document interface; PartDoc, AssemblyDoc and DrawingDoc are type-specific interfaces you obtain from it.
- ModelDocExtension exposes extended functionality, including selection by ID and several save options.
- FeatureManager (reached from the model) creates features; SketchManager creates sketch geometry.
- Interface hierarchy matters: a method you need is often on a different interface than you expect, so confirm it in API Help.
Macro recorder: useful, but limited
The macro recorder is a fast way to discover which calls produce a given UI action, but recorded code is verbose, tied to the current selection and view state, and often hard-codes values. Treat it as a hint generator, then rewrite the logic with proper object references and error handling. Exam tasks reward code that works on the supplied model, not code that replays your mouse.
API Help navigation
Because the issuer's list is non-exhaustive, you will meet calls you have never typed. Practice this loop: identify the object you hold, search its interface page, scan members for the verb you need, read the parameter list and return type, and check the "Remarks" and example sections for gotchas. Fluency here is arguably the single most valuable CSWP-API skill.
Sketches, Dimensions and Features
Domains 3, 6 and 7: Part design, sketch entities and features
Part automation questions typically chain several steps: open or create a part, select a plane, sketch geometry, dimension it, then build a feature.
- Select the target plane (by name) before inserting a sketch; sketch creation depends on a valid selection.
- Create sketch entities (lines, circles, rectangles) through SketchManager, then close the sketch before feature creation.
- Add dimensions to the sketch geometry and verify values afterward; a feature built on a wrongly sized sketch fails the result check.
- Feature creation such as extrudes and cuts requires correct end conditions, depth and direction arguments; many calls take long parameter lists, so read each argument in API Help.
- Clear the selection before each new operation to avoid features attaching to leftover selections.
A good drill: write a macro that builds a plate with a centered hole from scratch, then change one dimension through code and confirm the rebuild. Check results by reading back feature and dimension values rather than eyeballing the graphics area.
Selection, Traversal and Component States
Domains 5, 8 and 9: Assembly automation, selection/traversal and component states
Traversal means walking the feature tree, the component list or the face/edge collections to find the exact item you need.
- Iterate features with the first-feature and next-feature pattern, checking each feature's type name before acting.
- Get assembly components from the assembly document and iterate them, remembering that sub-assemblies nest.
- Use selection methods that match the object type; selecting by name, by ID or by point each behave differently.
- Component states: hide/show, suppress/unsuppress and resolve/lightweight are separate concepts. Know which API call changes which state, and what happens to the component's children.
- Always test for Nothing/null returns before using an object; a failed selection returns a failure flag, not an exception you can rely on.
Key Takeaway
Hide, suppress and resolve are not interchangeable. A hidden component is still loaded and in the BOM logic of the model; a suppressed one is not; a lightweight one must be resolved before some operations succeed. Build a tiny three-component assembly and toggle each state in code until the differences feel automatic.
Drawings, Views, BOMs and Saving
Five of the fifteen headings concern drawings, so this block repays deliberate practice. Note that the issuer retains overlapping headings (drawing automation, creation of drawings, inserting views), so expect the same underlying skills to appear in different framings.
| Objective | What to practice | Common failure point |
|---|---|---|
| Creation of drawings | Create a drawing from a template and set the sheet | Missing or wrong template path |
| Insert drawing views | Place standard views of a model at set positions and scales | Referencing the wrong model or view name |
| Insert a BOM | Add a bill of materials table to a drawing of an assembly | Active view or template for the table not supplied |
| Save drawings in different file formats | Use save-as with the target extension (such as PDF or DXF) | Ignoring error and warning flags on save |
| Add custom properties | Write file-level and configuration-specific properties | Writing to the wrong scope or configuration |
| Save and close documents | Save, then close by title or path | Closing before the save completes or using the wrong name |
Custom properties
Custom properties are a favorite automation target because the result is easy to verify. Practice adding, reading and overwriting properties at both the file level and the configuration level, and confirm the values by reading them back. Many real-world automation jobs boil down to these calls.
Closing and saving
Objective 15 looks trivial but trips people up: documents are closed by title or path, and an unsaved or still-referenced document can behave unexpectedly. Make "save, check the result, close" a habit in every macro you write.
Troubleshooting Checklist
Domain 2: Troubleshooting
Some tasks hand you broken or partial code and ask you to repair it. Work through the same checklist each time.
- Read every error message and line number before changing anything.
- Check object variables: is each one assigned, and of the correct interface type?
- Verify selection state: was the needed entity actually selected, and was the selection cleared afterward?
- Inspect arguments: wrong order, wrong enumeration value or wrong data type are frequent culprits in long parameter lists.
- Check return values: many calls return Boolean success flags or Nothing on failure.
- Confirm the document type: a part-only call on a drawing document fails quietly or loudly depending on the call.
- Step through with the debugger and watch variables rather than guessing.
For a candid look at where candidates struggle, see how hard the CSWP-API exam is.
Mapping Objectives to a Prep Calendar
This is the only scheduling section in the cheat sheet, and it is tied to the dependency order of the objectives themselves: you cannot automate drawings of parts you cannot create.
VBA basics and the object model
- Variables, loops, conditionals, procedures; get comfortable in the VBA editor
- Domain 1: SldWorks, ModelDoc2 and the document-type interfaces
- Record a few macros and read the generated code critically
Part automation
- Domains 3, 6, 7: sketches, dimensions, extrudes and cuts
- Domain 14: custom properties
- Domain 15: save and close
Selection, traversal and assemblies
- Domains 5, 8, 9: component iteration and hide/suppress/resolve
- Feature tree traversal drills
- Domain 2: debug deliberately broken macros
Drawings and timed rehearsal
- Domains 4, 10, 11, 12, 13: drawings, views, BOMs and format exports
- Run a full two-hour self-test mixing hands-on tasks and multiple-choice questions
- Review gaps in API Help navigation
Candidates with no programming background may want extra time in Week 1. Our CSWP-API training overview covers course options, and the exam dates guide helps with scheduling. Practice with realistic question styles on our CSWP-API practice test site, keeping in mind that the official guide's sample contains only four multiple-choice questions, not a full 28-question mock.
What the Exam Is Not
- Not a C# add-in exam. The focus is VBA. Add-in development and PDM API work are separate skill sets.
- Not a design-skills test. It is not the CSWP (Core) modeling exam; you are being evaluated on automation, not on how fast you build geometry by hand.
- Not a memorization test. With a non-exhaustive task list and a hands-on majority, understanding beats rote recall.
- Not training-gated. The three-day API Fundamentals course is recommended preparation, not a mandatory training-hours requirement, and it is a separate matter from the two-hour exam. Its curriculum headings are preparation topics, not an exam blueprint.
Frequently Asked Questions
The exam has 28 questions: 18 hands-on automation tasks and 10 multiple-choice questions, scored out of 100 points. You need 70 points to pass, and you have 120 minutes.
The exam focuses on Visual Basic for Applications (VBA). C# add-in development and PDM API work are outside the exam's stated focus.
The fee is US$49 for one North American attempt, excluding software and training. A retake requires a new CSWP-API credit and a wait of at least 14 days.
No. There is no prior certification requirement, and training courses are not admission requirements. SOLIDWORKS Design Essentials and API Fundamentals are recommended preparation, particularly if you are new to VBA.
According to the issuer's 2020 Certification Program Q&A, customer and student certifications do not expire.