Rotate a point around a center calculator
Turn a point around any pivot you choose: rotating (4, 2) by 90 degrees about (1, 1) lands it at (0, 4). Positive angles turn counterclockwise, and the distance to the pivot never changes. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- X
- 4
- Y
- 2
- Cx
- 1
- Cy
- 1
- Angle
- 90
- Rotated x
- 0
- Rotated y
- 4
Rotating a point around a center is a core rigid motion in coordinate geometry, CAD, robotics, and game development. Given a point P equals (x, y), a center C equals (cx, cy), and a rotation angle in degrees, the image P′ is obtained by translating so C is at the origin, applying the standard two-dimensional rotation matrix, and translating back. Positive angles rotate counterclockwise, matching the mathematical convention used in textbooks and most programming libraries.
What rotation about a center means and why people search for it
In the Cartesian plane, rotating a point about a center means every point moves along a circle whose center is the given pivot while preserving distance to that pivot. Algebraically you subtract the center from the point, multiply by the rotation matrix built from cosine and sine of the angle, then add the center back. Search intent clusters around phrases such as rotate a point around a center calculator, rotate coordinates about a pivot, 2D rotation matrix about a point, and find the image of a point after rotation.
Students want both coordinates after a ninety-degree or one-hundred-eighty-degree turn about an arbitrary pivot, not only about the origin. Unlike midpoint or reflection helpers, this landing focuses solely on planar rotation of one point about one center 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 a labeled center, or confirming that a CAD marker lands where the textbook 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 reflection over an axis, midpoint of a segment, or polar conversion, use those dedicated landings—this capacity focuses solely on rotating one plane point about one center by one angle in degrees.
FAQ
Is the rotate-a-point-around-a-center 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 (4, 2) land after a 90-degree turn about (1, 1)?
It lands at (0, 4). The point sits 3 units right of the center and 1 above it; a quarter turn counterclockwise moves it to 1 unit left of the center and 3 above.
How is a rotation about a center worked out?
Subtract the center from the point, rotate that offset with the cosine and sine of the angle, then add the center back. It is the same as moving the pivot to the origin and returning it afterwards.
What if the angle is zero or the center is the point itself?
You get the original coordinates back in both cases. A zero angle moves nothing, and a point that is its own center stays where it is for any angle.
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-center \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"x":4,"y":2,"cx":1,"cy":1,"angle":90}'const res = await fetch("https://api.kit.forhosting.com/geom/rotate-point-center", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"x": 4,
"y": 2,
"cx": 1,
"cy": 1,
"angle": 90
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/geom/rotate-point-center",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"x": 4,
"y": 2,
"cx": 1,
"cy": 1,
"angle": 90
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/geom/rotate-point-center", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"x":4,"y":2,"cx":1,"cy":1,"angle":90}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"x":4,"y":2,"cx":1,"cy":1,"angle":90}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/geom/rotate-point-center", 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": 4,
"y": 2,
"cx": 1,
"cy": 1,
"angle": 90
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "geom.rotate_point_center",
"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 five finite numbers—x, y, cx, cy, 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 a center means and why people search for it
With the angle measured in degrees and converted to radians for the trigonometric functions, the formulas are rotated_x equals cx plus dx times cos theta minus dy times sin theta, and rotated_y equals cy plus dx times sin theta plus dy times cos theta, where dx is x minus cx and dy is y minus cy. 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; rotating about the point itself (when the center coincides with the point) also returns the same coordinates for any angle. Send a JSON body with five required fields: x and y for the point, cx and cy for the center, 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 translate–rotate–translate sequence, 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 five inputs, returns rotated_x and rotated_y, and sets method to rotate_about_center so callers can assert the algorithm in tests. There is no matrix library, 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 five numbers always yield the same rotated_x and rotated_y fields. Wire the endpoint into symmetry demos, contest answer checkers, sprite pivot helpers, or preprocessing steps where you already prefer an explicit center and angle over opaque black-box widgets that cannot explain why a missing angle is rejected.
Integration use cases
Homework and exam rotation drills
Students and graders confirm rotated_x and rotated_y from a point, center, and angle 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-center oracle instead of reimplementing cos/sin pivots in every language.
CAD, robotics, and game pivot anchors
Tools that turn labels, collision origins, camera look-ats, or UI markers about a chosen pivot can recover the rotated point as structured JSON for import.
Technical questions
How do I rotate a point around a center with this API?
Send a JSON body with x, y, cx, cy, and angle (degrees, counterclockwise positive) to geom.rotate_point_center. The response returns rotated_x and rotated_y after the standard 2D rotation about the center.
What formula does the rotate-about-center calculator use?
With dx = x−cx, dy = y−cy and θ = angle·π/180: rotated_x = cx + dx·cos(θ) − dy·sin(θ), rotated_y = cy + dx·sin(θ) + dy·cos(θ). The method field is always rotate_about_center.
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.