- What This Exam Actually Is (and Isn't)
- Format, Rules, and Proctoring Mechanics
- The Seven Official Topic Groups
- Where Candidates Lose Points: Concrete Skills to Master
- Official Preparation Resources
- A Domain-Ordered Study Schedule
- Exam-Day Execution
- Vouchers, Retakes, and Results
- After You Pass
- Frequently Asked Questions
- The exam has 45 multiple-choice questions, a 90-minute limit, and a 60% passing score.
- CodeHS lists seven official topic groups, from Data Types and Operators through Strings.
- Lists and strings include indexing, slicing, methods, and two-dimensional lists, all explicitly in scope.
- Each voucher covers one attempt; every retake requires another voucher purchased through your school or district.
What This Exam Actually Is (and Isn't)
The CHS-P1 exam is the CodeHS Python Level 1 Certification. It is issued and administered by CodeHS, the same platform many schools use to teach introductory programming. It is not the Python Institute's PCEP, it is not a course-completion certificate, and it is not a teacher microcredential. If you have seen other credentials that share the "CHS-P1" label, set those facts aside: nothing about their fees, dates, or syllabi applies here. For a plain-language orientation, see What Is CHS-P1 Certification?
This guide focuses on one goal: helping you pass on the first attempt. Because every attempt requires a purchased voucher, a first-try pass is the efficient outcome for you, your teacher, and your school's budget. If you are still sizing up the challenge, our breakdown of how hard the CHS-P1 exam is pairs well with this plan.
Format, Rules, and Proctoring Mechanics
Knowing the container your knowledge must fit into removes a surprising amount of test-day stress. Here is what CodeHS documents about the exam.
| Feature | What to Expect |
|---|---|
| Question count and type | 45 multiple-choice questions, randomly selected |
| Time limit | 90 minutes, online |
| Passing score | 60% |
| Sitting | Must be completed in one sitting |
| Where you test | At home or at school, monitored by a teacher or authorized proctor |
| Tools | Python examination reference sheet provided; paper, pencil, and calculator suggested |
| Integrity controls | Honor Code and Focus Mode |
| Accommodations | Extended time and read-aloud supported; other requests need platform review |
Rules you must not break
External websites, collaboration, copying or sharing exam questions, and running code in another website or program are all prohibited. That last point matters for a Python exam: you cannot paste a snippet into an outside interpreter to see what it prints. You must trace the code by hand, which is exactly why paper and a pencil are on the suggested list.
Focus Mode blocks navigation to other CodeHS pages during the exam. It is not described as a system-wide browser lockdown, so do not treat it as a substitute for your own discipline. Monitoring runs through the CodeHS Certifications app and Proctor Dashboard, with your teacher or an authorized proctor watching the session.
Why the reference sheet changes your preparation
Because a Python examination reference sheet is provided, rote memorization of every method name is less important than knowing what each tool does and when to reach for it. Still, do not plan to learn the sheet during the exam. Ninety minutes for 45 questions is workable, but time spent hunting for syntax is time not spent tracing code. Spend part of your practice sessions with the sheet open so its layout feels familiar.
The Seven Official Topic Groups
CodeHS publishes seven top-level topic headings for the exam. These are official topic groups, not a percentage-weighted blueprint, so do not assume equal or unequal weighting between them. The full walkthrough lives in the complete guide to all 7 content areas; here is the working summary.
Domain 1: Data Types and Operators
The foundation for everything else. You need to predict what an expression evaluates to, including the type of the result.
- Distinguish integers, floats, strings, and Booleans, and know how they behave in arithmetic
- Apply arithmetic, comparison, and logical operators with correct precedence
- Recognize type conversion and what happens when types are mixed
Domain 2: Conditionals
Questions here test whether you can follow a branching program to the line that actually executes.
- Trace if, elif, and else chains, including which branch fires first
- Evaluate compound Boolean conditions built from and, or, and not
- Spot overlapping conditions that make a later branch unreachable
Domain 3: Loops
Loop tracing is mechanical but unforgiving; one off-by-one slip changes the answer.
- Work with for and while loops and the range function
- Understand where loops stop and what the final variable values are
- Use continue to skip to the next iteration; CodeHS lists it explicitly in the exam overview
Domain 4: Program Structure
How a program is organized: functions, parameters, return values, and scope.
- Trace function calls, arguments, and what gets returned versus printed
- Understand how variables behave inside and outside functions
- Read multi-part programs where one function calls another
Domain 5: Error Handling
Expect questions about what happens when code fails and how a program can respond.
- Recognize common error types from short code snippets
- Follow try and except flow to determine which lines run
- Distinguish code that raises an error from code that runs but produces the wrong result
Domain 6: Lists
One of the richest areas, and the overview explicitly names one- and two-dimensional lists plus list methods, indexing, and slicing.
- Index into one-dimensional lists and nested (two-dimensional) lists
- Slice lists and predict the resulting sublist
- Apply list methods and know which ones modify the list in place
Domain 7: Strings
Strings behave like sequences, so indexing and slicing carry over from lists, with extra method knowledge on top.
- Index and slice strings, including negative indices
- Apply string methods and predict their returned values
- Remember that strings are immutable, so methods return new strings
Where Candidates Lose Points: Concrete Skills to Master
On a multiple-choice code-reading exam, most missed questions come from a small set of predictable traps. These are the ones worth drilling, grouped by how they show up.
Trace, don't skim
The dominant question style is "what does this code output?" or "what is the value of this variable after this runs?" Read every line, and write down variable values as they change. Candidates who skim and pattern-match get caught by questions designed to look like something familiar but differ in one operator or one index.
Slicing and indexing boundaries
Slicing appears in both Lists and Strings, so a weakness here costs you twice. Practice until these facts are automatic:
- The start index of a slice is included; the end index is excluded
- Negative indices count from the end of the sequence
- Going past the end with a slice is forgiving, but a single out-of-range index raises an error
- For a two-dimensional list, the first index picks the row and the second picks the item within it
Methods that return versus methods that modify
A classic trap: a list method that changes the list in place returns nothing useful, while a string method returns a new string and leaves the original untouched. Questions will print a variable after calling a method and ask what appears. If you do not know which category the method falls into, you will guess. Build a two-column personal list: "changes the original" versus "returns a new value."
Loop control: break versus continue
Because continue is named in the official overview, expect at least one question that depends on understanding that it skips the rest of the current iteration without ending the loop. Trace a small example by hand until the difference from stopping the loop entirely is obvious.
Operator precedence and type results
Data Types and Operators questions often hinge on a single detail: integer versus float results, the order operations are evaluated, or how a comparison feeds a Boolean expression. Slow down on these; they are quick to answer correctly and quick to answer wrongly. The calculator you are allowed can verify arithmetic, but it will not tell you what Python does with types, so know the language rules themselves.
Official Preparation Resources
CodeHS offers a public Certification Practice course listing in its curriculum catalog, and the listing identifies a practice course matching the Level 1 certification. The Introduction to Python Programming course is the recommended learning path. Treat these as study aids, not as exhaustive definitions of what is tested: preparation courses and practice listings are not additional exam domains, and they do not establish official domain weights. The scope of the exam is defined by the seven topic headings in the CodeHS exam overview.
A practical approach is to use the course to learn each topic, then use timed multiple-choice practice to learn the exam's question style. Our CHS-P1 practice tests are built around that second skill: reading short code and choosing the correct output under a clock. For a quick last-pass reference, keep the CHS-P1 cheat sheet nearby, and browse CHS-P1 training options if you want structured instruction.
A Domain-Ordered Study Schedule
Generic planning advice is cheap; what matters is sequencing the topics so each builds on the last. The order below follows dependency: you cannot trace a loop reliably until operators and conditionals are solid, and you cannot manipulate lists and strings well until loops feel natural. Adjust the pace to your own calendar and your teacher's exam window.
Data Types and Operators + Conditionals
- Hand-evaluate expressions and note the resulting type each time
- Trace if/elif/else chains with several different input values
- Practice compound Boolean conditions until they are quick
Loops + Program Structure
- Trace for and while loops on paper, tracking every variable
- Drill break versus continue with tiny examples
- Trace function calls, parameters, return values, and scope
Lists + Strings (the heaviest content)
- Index and slice one- and two-dimensional lists repeatedly
- Build your "modifies in place versus returns new" method table
- Practice string indexing, slicing, and methods with negative indices
Error Handling + Full Timed Practice
- Study error types and try/except flow
- Take full-length 45-question sets in 90 minutes with the reference sheet open
- Review misses by domain and revisit your weakest topic group
Lists and Strings get their own week because they are named in detail in the official overview and because each reinforces the other. If your teacher's testing window is shorter than four weeks, compress Weeks 1 and 2 first, since those topics tend to be review for students who have already completed a course. Check CHS-P1 exam dates and scheduling to plan backward from your window, and see the companion CHS-P1 study guide for additional planning angles.
Exam-Day Execution
Ninety minutes for 45 questions averages two minutes per question, which is comfortable for most code-tracing items but tight if you get stuck on a few. Use that arithmetic to your advantage.
- Set up your workspace first. Paper, pencil, and calculator at hand, nothing else open, and your proctor aware you are starting.
- Do a quick pass. Answer questions you can trace in under a minute and note the ones that need longer work.
- Trace on paper. Write variable values line by line rather than holding them in your head.
- Eliminate before guessing. On multiple choice, rule out outputs that are impossible given the types or loop bounds.
- Use the reference sheet purposefully. Look up a method only when you are certain you need it.
- Leave time to review flagged items. Since you must finish in one sitting, plan your last ten minutes deliberately.
Key Takeaway
Because outside tools and code execution are prohibited, your hand-tracing speed is the real exam skill. Practice with pencil and paper, not just in an editor, so test day does not feel like a different activity.
Vouchers, Retakes, and Results
Access to the exam runs through vouchers. Pricing for school and district vouchers is provided by direct quote from CodeHS, and no public numeric fee was verified, so we do not print a dollar figure here. The mechanics are what matter for planning:
- Each purchased voucher permits one attempt
- Retakes have no numerical limit, but every additional attempt requires another purchased voucher
- Unused school or district vouchers expire at the end of the contract term and do not roll over between school years
The last point is easy to overlook: if your class holds unused vouchers, talk to your teacher about testing within the current contract term. For the broader picture of costs, read CHS-P1 certification cost.
What you receive after testing
Results are released within 36 hours on school days. You get an overall score plus a topic-level performance report, which is the most valuable part if you ever need to retake: it shows which topic groups held you back. Successful candidates receive a downloadable certificate, and earned certificates expire after 10 years. To understand the threshold itself, see CHS-P1 passing score.
After You Pass
The CodeHS Python Level 1 certificate is a credential of foundational skill, best suited to students building a record of programming competence early. It signals that you can read and reason about basic Python, which is useful on a school transcript, in a portfolio, or as a stepping stone toward more advanced coursework. Be realistic about its role: it is an entry-level credential, not a professional license. If you are weighing its value, the worth-it analysis covers the tradeoffs, and CHS-P1 jobs discusses how foundational Python credentials fit into early career paths. Ready to measure yourself against exam-style questions? Try the full CHS-P1 practice test.
Frequently Asked Questions
The exam has 45 multiple-choice questions and a 90-minute time limit. It must be completed in one sitting, and questions are randomly selected.
The passing score is 60%. This is a threshold on your own result, not a cohort pass rate, and no official pass rate has been verified.
Yes. There is no numerical limit on retakes, but each attempt requires another purchased voucher, since each voucher covers a single attempt.
No. External websites, collaboration, sharing exam questions, and running code in another website or program are prohibited. A Python reference sheet is provided, and paper, a pencil, and a calculator are suggested.
Results are released within 36 hours on school days, with an overall score and a topic-level performance report. Successful candidates can download a certificate, which expires after 10 years.