Rotate a point around the origin calculator
Spin a point about the origin by any angle in degrees: (1, 0) turned 90 degrees becomes (0, 1). Positive angles go counterclockwise, the textbook convention, and the distance from the origin stays the same. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- X
- 1
- Y
- 0
- Angle
- 90
- Rotated x
- 0
- Rotated y
- 1
Rotating a point around the origin is the classic first rigid motion in coordinate geometry and linear algebra. Given a point P equals (x, y) and a rotation angle in degrees, the image P′ is obtained by applying the standard two-dimensional rotation matrix about (0, 0): the x-coordinate becomes x cosine theta minus y sine theta, and the y-coordinate becomes x sine theta plus y cosine theta. Positive angles rotate counterclockwise, matching the mathematical convention used in textbooks and most programming libraries.
What rotation about the origin means and why people search for it
In the Cartesian plane, rotating a point about the origin means every point moves along a circle centered at (0, 0) while preserving its distance from the origin. Search intent clusters around phrases such as rotate a point around the origin calculator, rotation matrix about origin, 2D rotate coordinates origin, find the image of a point after rotation about origin, and counterclockwise rotation formula degrees.
Students want both coordinates after a ninety-degree or one-hundred-eighty-degree turn about the origin, which is the default pivot in almost every textbook chapter before arbitrary centers appear. Unlike midpoint or reflection helpers, this landing focuses solely on planar rotation of one point about the origin by one angle.
Practical use, limits, pricing, and delivery channels
Use the browser tool when you want an immediate rotation while checking homework, verifying a figure after a turn about the coordinate origin, or confirming that a textbook image lands where the answer key claims. Coordinates and the angle 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, while the angle is always interpreted in degrees.
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 rotation about a non-origin center, reflection over an axis, or midpoint of a segment, use those dedicated landings—this capacity focuses solely on rotating one plane point about the origin by one angle in degrees.
FAQ
Is the rotate-a-point-around-the-origin calculator free?
The browser tool runs free on your device.
Is the angle in degrees or radians, and which way is positive?
Angle is in degrees with counterclockwise positive (mathematical convention).
Where does (1, 0) go after a 90-degree turn about the origin?
It goes to (0, 1). The point starts on the positive x-axis, and a quarter turn counterclockwise carries it onto the positive y-axis, still one unit from the origin.
What is the formula for rotating a point about the origin?
The new x is x times the cosine of the angle minus y times its sine. The new y is x times the sine plus y times the cosine, with the angle read in degrees.
What does a half turn do to a point?
A half turn about the origin flips both signs, so the point lands in the opposite position, roughly at minus x and minus y. A zero angle leaves the point exactly where it was.
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/rotate-point-origin \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"x":1,"y":0,"angle":90}'const res = await fetch("https://api.kit.forhosting.com/geom/rotate-point-origin", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"x": 1,
"y": 0,
"angle": 90
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/geom/rotate-point-origin",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"x": 1,
"y": 0,
"angle": 90
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/geom/rotate-point-origin", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"x":1,"y":0,"angle":90}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"x":1,"y":0,"angle":90}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/geom/rotate-point-origin", 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": 1,
"y": 0,
"angle": 90
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "geom.rotate_point_origin",
"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 three finite numbers—x, y, and angle—rejects missing or non-numeric fields (especially a non-numeric angle) with invalid_input so failed validation is never charged, and returns rotated_x and rotated_y together with an echo of the inputs.
What rotation about the origin means and why people search for it
Algebraically you multiply the coordinate vector by the two-by-two rotation matrix built from cosine and sine of the angle: rotated_x equals x times cos theta minus y times sin theta, and rotated_y equals x times sin theta plus y times cos theta, where theta is the angle converted from degrees to radians. Survey and CAD assistants want structured JSON they can paste into reports without reimplementing floating-point trigonometry in every language. Delivering rotated_x and rotated_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 rotated coordinates
In particular, a non-numeric angle is never silently treated as zero—validation fails with a clear message that the angle must be a finite number. A zero-degree angle returns the original point; a one-hundred-eighty-degree turn maps (x, y) to approximately (−x, −y). Send a JSON body with three required fields: x and y for the point, and angle for the rotation in degrees with counterclockwise positive. 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 engine converts degrees to radians, evaluates cosine and sine once, applies the origin rotation matrix, and rounds each output coordinate to a stable decimal precision so the same inputs always yield the same JSON across JavaScript engines. The response echoes the three inputs, returns rotated_x and rotated_y, and sets method to rotate_about_origin so callers can assert the algorithm in tests. There is no matrix library dependency beyond standard Math.cos and Math.sin, no external geometry service, and no random noise—only pure arithmetic 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 three numbers always yield the same rotated_x and rotated_y fields. Wire the endpoint into unit-circle demos, contest answer checkers, sprite origin spins, or preprocessing steps where you already prefer rotation about (0, 0) over an arbitrary pivot.
Integration use cases
Homework and exam origin-rotation drills
Students and graders confirm rotated_x and rotated_y from a point and angle about the origin without a local CAS, including rejection when the angle is missing or non-numeric.
Deterministic fixtures for geometry tests
Pipelines that seed unit tests or interactive transform demos can call a pure rotation-about-origin oracle instead of reimplementing cos/sin origin spins in every language.
CAD, robotics, and game origin spins
Tools that turn labels, collision points, camera look-ats, or UI markers about the coordinate origin can recover the rotated point as structured JSON for import.
Technical questions
How do I rotate a point around the origin with this API?
Send a JSON body with x, y, and angle (degrees, counterclockwise positive) to geom.rotate_point_origin. The response returns rotated_x and rotated_y after the standard 2D rotation about the origin.
What formula does the rotate-about-origin calculator use?
With θ = angle·π/180: rotated_x = x·cos(θ) − y·sin(θ), rotated_y = x·sin(θ) + y·cos(θ). The method field is always rotate_about_origin.
What happens if the angle is missing or non-numeric?
The request fails with invalid_input because a finite number is required for angle (and for every coordinate). Those validation failures are not charged.