Reflect a point over the y-axis calculator
Enter a point and get its mirror image across the y-axis: (3, 4) becomes (−3, 4), since the horizontal coordinate changes sign and the height stays the same. Handy for checking homework or flipping a sketch. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- X
- 3
- Y
- 4
- Reflected x
- -3
- Reflected y
- 4
Reflecting a point over the y-axis is one of the first rigid motions students meet in coordinate geometry: the image of P equals (x, y) is P′ equals (−x, y). The horizontal distance to the axis is preserved, the vertical coordinate stays the same, and the segment joining a point to its image is perpendicular to the mirror line. Students, tutors, CAD helpers, game developers, and contest solvers need that image as stable numbers they can pin in tests, not only a sketch on paper.
What reflection over the y-axis means and why people search for it
In the Cartesian plane the y-axis is the vertical line x equals zero. Equivalently, the midpoint of the segment from P to P′ always lies on the y-axis, and that segment is horizontal. Search intent clusters around phrases such as reflect a point over the y-axis calculator, reflection over y-axis formula, find the image of a point across the y-axis, and coordinate geometry reflection.
The mapping is an involution: applying it twice recovers the original point. Unlike distance or midpoint helpers, this landing focuses solely on reflection of one plane point across the vertical axis.
Practical use, limits, pricing, and delivery channels
Use the browser tool when you want an immediate reflection while checking homework, flipping a sketch across the vertical axis, or verifying a figure without installing a computer-algebra system. Coordinates may be any finite numbers within a large absolute bound suitable for ordinary CAD and classroom figures; the response coordinates share the same unit system you already use. There is no language model, no external geometry service, and no randomness, so the capacity is safe to pin in continuous-integration checks and reproducible lesson materials.
If you need reflection over the x-axis, the origin, or an arbitrary line, use those dedicated landings when they exist—this capacity focuses solely on reflecting one plane point over the y-axis.
FAQ
Is the reflect-over-y-axis calculator free?
The browser tool runs free on your device.
What if the point already lies on the y-axis?
If x is zero, the reflected point equals the original point. Only missing or non-finite coordinates are rejected.
What is the reflection of (3, 4) over the y-axis?
It is (−3, 4). The first coordinate changes sign and the second stays the same, so the point jumps to the other side of the vertical axis.
Where is the midpoint between a point and its image?
Always on the y-axis. The segment that joins a point to its reflection is horizontal and is cut in half by the mirror line, which is a quick way to check an answer.
Does the distance to the axis change?
No. The image keeps the same horizontal distance to the y-axis as the original point, only on the opposite side, and its vertical coordinate is untouched.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/geom/reflect-point-y-axis \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"x":3,"y":4}'const res = await fetch("https://api.kit.forhosting.com/geom/reflect-point-y-axis", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"x": 3,
"y": 4
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/geom/reflect-point-y-axis",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"x": 3,
"y": 4
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/geom/reflect-point-y-axis", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"x":3,"y":4}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"x":3,"y":4}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/geom/reflect-point-y-axis", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"x": 3,
"y": 4
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "geom.reflect_point_y_axis",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
This capacity accepts two numbers—x and y—checks that every coordinate is present and finite, and returns the reflected pair as reflected_x and reflected_y together with an echo of the input. Missing or non-numeric fields fail immediately with invalid_input so failed validation is never charged.
What reflection over the y-axis means and why people search for it
Reflection over that line maps every point to the unique image with the same perpendicular distance on the opposite side of the axis: the formula is reflected_x equals negative x and reflected_y equals y. Delivering reflected_x and reflected_y as JSON makes the result easy to diff in continuous integration, feed into a larger pipeline, or copy into notes.
How this calculator validates input and computes the y-axis reflection
A point already on the y-axis (x equals zero) is accepted because the image is that same point; only incomplete or non-numeric coordinates are rejected. Send a JSON body with the two required fields x and y. Each field must be a finite number (JSON numbers or numeric strings are accepted). The engine rejects missing fields, empty strings, NaN, and infinities with invalid_input so those failed calls are not charged. After parsing, the reflection is computed as reflected_x equals negative x and reflected_y equals y. Results are rounded to a stable decimal precision so the same coordinates always yield the same JSON across JavaScript engines. The response echoes the two input coordinates, returns reflected_x and reflected_y, and sets method to reflect_over_y_axis so callers can assert the algorithm in tests. There is no trigonometry, no matrix library, and no external geometry service—only a sign change on x and a copy of y on a Worker isolate.
Practical use, limits, pricing, and delivery channels
Each successful request is one billable item at $0.002; failed validation does not consume balance. Results are fully deterministic: the same two numbers always yield the same reflected_x and reflected_y fields. Wire the endpoint into symmetry demos, contest answer checkers, sprite mirror helpers, or preprocessing steps where you already prefer an explicit y-axis reflection over opaque black-box widgets that cannot explain why a missing y is rejected.
Integration use cases
Homework and exam reflection drills
Students and graders confirm reflected_x and reflected_y from a single point without a local CAS, including rejection when any coordinate is missing or non-numeric.
Deterministic fixtures for geometry tests
Pipelines that seed unit tests or interactive symmetry demos can call a pure y-axis reflection oracle instead of reimplementing the sign flip in every language.
CAD, mesh, and game mirror anchors
Tools that flip labels, collision origins, or UI markers across a vertical symmetry line can recover the reflected point as structured JSON for import.
Technical questions
How do I reflect a point over the y-axis with this API?
Send a JSON body with x and y to geom.reflect_point_y_axis. The response returns reflected_x = −x and reflected_y = y.
What formula does the y-axis reflection calculator use?
Reflection over the y-axis is reflected_x = −x and reflected_y = y. The method field is always reflect_over_y_axis.
What happens if a coordinate is missing or non-numeric?
The request fails with invalid_input because a finite number is required for every field. Those validation failures are not charged.