Personality test examples usually mean sample questions: strings you skim to get a feel for a test. For the developer who has to store the answers and compute a result, personality test examples are something else entirely — the item's format decides the data model, the validation rules, and the scoring function, long before the wording enters the picture. This post treats five personality test examples as data: a plain Likert item, a reverse-keyed Likert item, a bipolar semantic-differential item, a forced-choice block, and an open response no function should ever score. Four formats get TypeScript types and a scorer, the fifth gets a reason to stay out of the scorer, and the scored statements come from a public-domain item pool.
Personality test examples you can legally reuse: the IPIP
Many personality test examples online come from commercial instruments, which is awkward when the personality test examples you want are headed into a real product. The exception is the IPIP public-domain item pool: its items and scales are in the public domain, so anyone can copy, edit, translate, or use them for any purpose, without permission and without a fee. For a developer hunting personality test examples, that sentence is most of the license review. (Your own legal check still applies to anything you add around the items.)
The pool's Big-Five factor markers include a 10-item Extraversion scale — five positively keyed statements, five negatively keyed ones — with an alpha of .87 as listed on the IPIP Big-Five factor markers key page. The IPIP personality test examples share one response set: 1 Very Inaccurate, 2 Moderately Inaccurate, 3 Neither Accurate Nor Inaccurate, 4 Moderately Accurate, 5 Very Accurate. Plenty of roundups of examples of personality tests run long on questions and short on licensing; the IPIP is a pool of personality test examples you can actually ship.
Formats 1 and 2: Likert personality test examples and reverse keying
A Likert scale personality test item is one statement plus an ordered response set, and the IPIP scoring rule fits in three sentences: positively keyed items take the answer's value as is; negatively keyed items are reversed, so Very Inaccurate counts 5 and Very Accurate counts 1; the scale score is the sum. "Am the life of the party." is keyed +1 and "Don't talk a lot." is keyed −1. Most lists of personality test sample questions leave out that sign, which is the half a developer needs: the text is content, the key is logic.
Reverse keying exists because respondents drift. The IPIP administration page notes there is no standardized procedure for administering IPIP items, and that its sample questionnaire distributes items from different scales while alternating +keyed and −keyed items so respondents keep attending to content. A long run of same-keyed personality test examples invites identical answers — "Very Accurate" straight down the line — which lowers variance and flattens the scale. In personality test examples stored as data, alternating the key costs exactly one integer per item.
type LikertItem = { kind: 'likert'; id: string; text: string; scale: 'E'; keyed: 1 | -1; }; function scoreLikert(item: LikertItem, answer: number): number { return item.keyed === -1 ? 6 - answer : answer; } With keyed in the data, formats 1 and 2 collapse into one function — the difference between these two personality test examples is data, not code. Here are all ten Extraversion items as JSON, ten personality test examples you can copy tonight without asking anyone's permission:
[ { "kind": "likert", "id": "e1", "text": "Am the life of the party.", "scale": "E", "keyed": 1 }, { "kind": "likert", "id": "e2", "text": "Feel comfortable around people.", "scale": "E", "keyed": 1 }, { "kind": "likert", "id": "e3", "text": "Start conversations.", "scale": "E", "keyed": 1 }, { "kind": "likert", "id": "e4", "text": "Talk to a lot of different people at parties.", "scale": "E", "keyed": 1 }, { "kind": "likert", "id": "e5", "text": "Don't mind being the center of attention.", "scale": "E", "keyed": 1 }, { "kind": "likert", "id": "e6", "text": "Don't talk a lot.", "scale": "E", "keyed": -1 }, { "kind": "likert", "id": "e7", "text": "Keep in the background.", "scale": "E", "keyed": -1 }, { "kind": "likert", "id": "e8", "text": "Have little to say.", "scale": "E", "keyed": -1 }, { "kind": "likert", "id": "e9", "text": "Don't like to draw attention to myself.", "scale": "E", "keyed": -1 }, { "kind": "likert", "id": "e10", "text": "Am quiet around strangers.", "scale": "E", "keyed": -1 } ] Format 3: bipolar personality test examples (semantic differential)
Format 3 swaps agree/disagree for two poles. Open Psychometrics' OEJTS 1.2 uses 60 items in two sections, and in the first section each item places two opposing personality descriptions at the ends of a five-point scale — "honest ..... a liar" is the canonical example. Personality test questions examples in this shape are the easiest to store as signed numbers: map the five positions to −2 through +2 and the midpoint becomes a true zero, with the sign naming the pole the respondent leaned toward. Bipolar personality test examples also make "no lean" explicit: a neutral answer is 0, not 3.
type BipolarItem = { kind: 'bipolar'; id: string; left: string; right: string; scale: string; }; function scoreBipolar(_item: BipolarItem, answer: number): number { // 1..5 -> -2..+2; negative leans toward `left`, positive toward `right` return answer - 3; } The item carries both pole labels so the UI can render the scale without lookups. In the combined file below, these personality test examples sit next to Likert items with nothing but the kind tag to tell them apart.
Format 4: forced-choice personality test examples, and why ipsative scores don't compare across people
Format 4 is where personality test examples stop behaving like ordinary numbers. In a forced choice personality test block, the respondent ranks statements or distributes a fixed budget of points among options, and every person's block sums to the same constant. Scores from such personality test examples describe an ordering within a person, not a level between people — ipsative data. Two respondents each distributing 10 points across three statements keyed to scales E, A, and C make the limit concrete:
| Respondent | E | A | C | Sum |
|---|---|---|---|---|
| Person 1 | 6 | 3 | 1 | 10 |
| Person 2 | 2 | 5 | 3 | 10 |
Person 1's ordering is E over A over C; Person 2's is A over C over E. In forced-choice personality test examples, those orderings are the signal. But Person 2 "beat" Person 1 on C, three points to one, and that comparison means nothing: both budgets are pinned at 10, so every point given to one scale is taken from another. Give the same two people ordinary Likert personality test examples instead, and Person 1's absolute C sum could exceed Person 2's. That is why personality test examples with ipsative scoring should never feed a page that ranks people against each other. The IPIP Likert items above are normative: each answer stands on its own scale.
type ForcedOption = { text: string; scale: string }; type ForcedChoiceItem = { kind: 'forced'; id: string; options: ForcedOption[]; }; type Item = LikertItem | BipolarItem | ForcedChoiceItem; // points[i] = points the respondent gave to item.options[i] function scoreForced( item: ForcedChoiceItem, points: number[], budget = 10 ): Record<string, number> { if (points.length !== item.options.length) throw new Error('one value per option'); const total = points.reduce((a, b) => a + b, 0); if (total !== budget) throw new Error(`points must sum to ${budget}`); const perScale: Record<string, number> = {}; item.options.forEach((option, i) => { perScale[option.scale] = (perScale[option.scale] ?? 0) + points[i]; }); return perScale; } scoreForced rejects any block that doesn't spend exactly the budget, because the constant total is the whole definition of the format.
Format 5: objective vs projective personality test examples
Everything above is objective scoring — fixed items, fixed options, a rule that turns answers into numbers with no judgment calls — and that property is what makes those personality test examples codeable at all. Lists of objective personality tests examples rarely state it, but the contrast is projective testing. The classic examples of projective personality tests are the Rorschach inkblots and the TAT's picture stories, where a respondent reacts to an ambiguous stimulus and a trained human interprets the response. No scoring function supplies that interpretation, so open personality test examples get a plain treatment in code: store the text, display it, and keep it out of the scoring union.
Personality test examples with answers: the key is a scoring rule
"Personality test examples with answers" is a common search phrase, and it hides a small trap: a personality test has no answer key in the trivia sense. The answers are the scoring rule — which items load which scale, which are reversed, how raw values combine — and once that rule is explicit, personality test examples become unit-testable like any other function. Personality test examples that ship without tests are the ones that get mis-keyed quietly:
// tsconfig: "resolveJsonModule": true, "esModuleInterop": true import assert from 'node:assert/strict'; import itemsJson from './items.json'; const items = itemsJson as Item[]; const extraversion = items.filter( (item): item is LikertItem => item.kind === 'likert' ); const neutral = extraversion.reduce( (sum, item) => sum + scoreLikert(item, 3), 0 ); assert.equal(neutral, 30); const quiet = extraversion.find((item) => item.keyed === -1)!; assert.equal(scoreLikert(quiet, 5), 1); assert.equal(scoreLikert(quiet, 1), 5); The first assertion pins the midpoint: ten items answered 3, "Neither Accurate Nor Inaccurate," must total 30 on a scale running 10 to 50, and any mis-keyed item drifts it. The second pins the reversal: agreement with "Don't talk a lot." has to subtract from Extraversion, not add. Implement the reversal backwards and quiet people start looking like the life of the party. Personality test examples with explicit tests keep that bug out of production, and the tests are short enough to live beside the items they guard.
If you would rather see the format running before writing code, there is a live 8-statement, 1-to-5 Likert example you can inspect: eight original statements on a 1-to-5 scale, scored in the browser, with a result reported as a position on a spectrum rather than a binary label. It is the smallest honest deployment of the item type above, and a good companion to the personality test examples in this section.
One JSON file for the codeable personality test examples
Because every scored format carries id and kind, the codeable personality test examples can share one JSON file, with kind as the discriminant the parser switches on (open responses live in a separate store). The two entries below join the ten Extraversion items in the same array. The forced-choice block reuses three IPIP items from the 50-item sample questionnaire ("Am the life of the party." for Extraversion, "Am interested in people." for Agreeableness, "Am always prepared." for Conscientiousness); the bipolar pole pair is my own example, not an OEJTS item:
[ { "kind": "bipolar", "id": "b1", "left": "quiet", "right": "talkative", "scale": "E" }, { "kind": "forced", "id": "f1", "options": [ { "text": "Am the life of the party.", "scale": "E" }, { "text": "Am interested in people.", "scale": "A" }, { "text": "Am always prepared.", "scale": "C" } ] } ] Before the file goes anywhere near production, a short validation checklist keeps the personality test examples honest:
- ids are unique across the whole file, because scores key off them
- every Likert item carries
keyedof 1 or −1, and the response labels ship with the data rather than being hard-coded in three components - bipolar left and right poles actually oppose each other
- forced-choice options point at the scales you intend, and the point budget is fixed
- nothing enters the scoring union unless its
kindis one of the three above — open responses stay out
The discriminated-union approach scales up, too: Building an MBTI cognitive functions test in JavaScript works through the data model and scoring for a longer test. It uses the same union-plus-scorer pattern on a bigger item bank.
Editor's note from Nico: I help out with PersonalityTest, so I have a vested interest in balanced Likert scoring. The items in this post are IPIP public-domain items, not PersonalityTest's own statements.
If you want to see balanced keying from the respondent's side, the main PersonalityTest quiz is 32 statements, half phrased toward each pole, scored in the browser. It uses eight statements per preference pair, a 5-point scale from Strongly disagree to Strongly agree, and four bars plus a provisional four-letter code, with a "balanced" reading when a pair lands near the middle. Answers are not uploaded, and there is no account or email gate.
MBTI® is a trademark of The Myers-Briggs Company. PersonalityTest is unofficial and not affiliated with The Myers-Briggs Company or the Myers & Briggs Foundation.
