J-pole antenna calculator
At 146 MHz on the 2-metre band, a J-pole needs a 1.0266865 m half-wave radiator, a 0.51334325 m matching stub and a 1.54002975 m long element. Enter the frequency in hertz and cut copper pipe or ladder line from these lengths, then trim. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Frequency
- 146,000,000
- Frequency hz
- 146,000,000 m
- Wavelength m
- 2.053373
- Half wave m
- 1.0266865
- Quarter wave m
- 0.51334325
This J-pole antenna calculator takes an operating frequency in hertz and returns the free-space element lengths used to cut a classic J-pole: the half-wave radiating section, the quarter-wave matching section, and the matching stub, together with the three-quarter-wave long element that forms the tall side of the J. The identities are fully deterministic: wavelength equals the vacuum speed of light divided by frequency, the half-wave radiator is one half of that wavelength, the quarter-wave length and the stub are each one fourth, and the long element is three fourths. With the exact SI speed of light two hundred ninety-nine million seven hundred ninety-two thousand four hundred fifty-eight metres per second, a one-hundred-forty-six-megahertz carrier on the two-metre amateur band yields roughly two metres of wavelength, about one metre of half-wave radiator, about half a metre of stub, and about one and a half metres of long element. The engine uses only finite arithmetic with no network calls, no sampling, and no date-dependent shortcuts.
Where J-pole length formulas fit in builds, study, and software
Amateur radio operators meet the J-pole when they want an inexpensive, mostly omnidirectional vertical for two metres or seventy centimetres that does not need radials, and the first question is always how long to cut the copper pipe or ladder line. Students meet the same geometry when a textbook introduces matching stubs, standing waves on a shorted quarter-wave section, and end-fed half-wave radiators, or when a lab asks for element lengths at a given carrier before anyone touches a torch.
Teachers can pre-generate answer keys for VHF and UHF examples without trusting opaque calculator apps that silently switch between feet, inches, and velocity-factor-adjusted lengths. Makers and emergency-communications groups use the free-space cut as a starting point for 146 MHz, 445 MHz, and other band-plan carriers, then trim on a VNA. Developers call the same contract from scripts to seed deterministic test vectors for antenna widgets, to normalize user-entered frequencies before layout demos, or to satisfy programming-challenge statements that demand J-pole half-wave, quarter-wave, and stub lengths rather than a hand-waved sketch.
Contest and homework practice often needs a fast, offline source of metre lengths so solutions can be checked without a network of radio-frequency simulators under time pressure. Product and education tools use the evaluation when a learner types a frequency and the interface must show wavelength plus the three classic J-pole cuts. Pair it with generic antenna-length or frequency helpers when you need related radio-frequency tools, and treat the numbers here as the free-space J-pole baseline rather than a finished mechanical drawing.
What you can do with it
Two-metre and seventy-centimetre copper-pipe builds
Convert a band-plan carrier in hertz into free-space half-wave, stub, and long-element metre cuts before trimming a J-pole on an analyzer.
Homework and matching-stub labs
Check textbook J-pole lengths at a stated frequency and confirm that the long element equals three quarters of a wavelength.
FAQ
What does the J-pole antenna calculator cost?
It is free in your browser on this page.
What happens if frequency is zero or negative?
Zero or negative frequency makes λ = c/f undefined, so the J-pole element lengths cannot be computed.
Why is the stub the same length as the quarter-wave section?
The long element is the distinct 3λ/4 cut.
Does this apply a velocity factor, and what unit is frequency in?
No velocity factor: lengths are free-space ideals. Frequency is in hertz (Hz); 146 MHz is 146000000. Optional precision (0–15, default 10) only affects displayed decimal places.
Why is the long element three quarters of a wavelength?
Because the tall side of the J contains both parts: the half-wave radiator on top and the quarter-wave section of the matching stub below it. Half plus a quarter gives three quarters.
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/phys/j-pole-antenna \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"frequency":146000000}'const res = await fetch("https://api.kit.forhosting.com/phys/j-pole-antenna", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"frequency": 146000000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/phys/j-pole-antenna",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"frequency": 146000000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/phys/j-pole-antenna", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"frequency":146000000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"frequency":146000000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/phys/j-pole-antenna", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"frequency": 146000000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "phys.j_pole_antenna",
"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.
Limits
max_abs_frequency_hz | 1000000000000000 |
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
What a J-pole is and what the response contains
A J-pole is an end-fed half-wave radiator that is matched to a low-impedance feed by a quarter-wave shorted stub, so the silhouette looks like the letter J: a long vertical conductor beside a short parallel stub, joined at the bottom. In free space the radiating portion is one half wavelength, the matching stub is one quarter wavelength, and the long conductor that you actually cut is three quarters of a wavelength because it includes both the radiator and the stub section below it. Those three lengths are the first cut every amateur, student, and copper-pipe builder wants before velocity factor, end effect, and nearby masts trim the physical metal. This calculator returns frequency_hz, wavelength_m, half_wave_m, quarter_wave_m, stub_m, long_element_m, the constant speed_of_light_m_s used, the precision applied, a method tag j_pole_free_space, a short formula string, and the unit tag m for the length fields. There is no approximate symbolic CAS path and no random sampling: the engine either builds exact floating-point lengths inside the supported frequency range or rejects the input with invalid_input. Rejected cases include missing frequency, non-finite values, magnitudes above the documented ceiling, and any zero or non-positive frequency, because lambda equals c over f is undefined when f is not positive.
How frequency is read and how lengths stay reproducible
Enter SI hertz: one hundred forty-six megahertz is one hundred forty-six million, not one hundred forty-six. Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces, hex prefixes, and non-numeric tokens are rejected with a clear message so a bad cell does not become a wrong pipe length. Cross-checks that the long element equals half-wave plus stub and that half-wave equals twice quarter-wave keep the J geometry consistent. The preferred field is frequency for f in hertz, but aliases f, freq, hz, and frequency_hz are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. Zero frequency is invalid and fails with invalid_input, as is any negative value, because wavelength and the J-pole fractions are not defined for non-positive operating frequency in this model. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for the numeric outputs, defaulting to ten and capped at fifteen so JSON goldens stay stable. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing the c over f formulas yourself.
Where J-pole length formulas fit in builds, study, and software
On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result.
Integration use cases
Deterministic test fixtures
Generate reproducible wavelength, half-wave, quarter-wave, and stub numbers for unit tests, property checks, and CI assertions.
Technical questions
How are J-pole half-wave, quarter-wave, and stub lengths defined?
With f > 0 and c = 299792458 m/s, wavelength λ = c/f, half-wave L_½ = c/(2f), quarter-wave and stub L_¼ = c/(4f), and long element 3λ/4 = 3c/(4f), all in metres.