ForHosting KIT · Math

Geometric sequence first term calculator

Work back to the start of a geometric sequence: if the fifth term is 162 and the ratio is 3, the first term is 2, because 162 divided by 81 is 2. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Term: 162
Resistance (Ω): 3
N: 5

You get

First term: 2
Ratio power: 81
Max n: 10,000

Recovering the first term of a geometric sequence is a classic inverse problem: you already know one later value, where it sits in the list, and the fixed multiplier between consecutive terms, and you need the starting value that makes the progression consistent. Students use it to check homework when a worksheet gives the fifth or tenth term instead of a1. Teachers and exam generators need an oracle that rejects impossible cases such as a zero ratio after the first position.

Working backwards along a geometric sequence

In a geometric sequence each term is the previous one multiplied by the same number, the common ratio. If you know one later term, its position and the ratio, you can walk back to the start: divide the known term by the ratio once for every step between it and the first position. That is the same as dividing by the ratio raised to one less than the position. For a fifth term of 162 with a ratio of 3, you divide by 3 four times, or by 81 at once, and the first term is 2.

When it helps and the usual mistakes

Worksheets often give the fifth or tenth term instead of the first, and a quick check of the answer saves a lot of rework. The same back-calculation recovers the starting value of a process that multiplies by a fixed gain at every step. The most frequent mistake is raising the ratio to the position itself instead of one less, forgetting that the first term needs no multiplication at all. Another is treating an arithmetic sequence as geometric: if the terms grow by adding a constant, this method does not apply.

Where a first-term recovery tool earns its keep

Classrooms meet this problem when a word problem states that the fifth term of a geometric progression is one hundred sixty-two and the common ratio is three, then asks for the first term. Tutoring platforms and exam-prep generators need a deterministic oracle that marks wrong a zero ratio after position one instead of inventing an arbitrary a1.

Engineering notebooks sometimes observe a measured value at step n of a process that multiplies by a fixed gain each step and must back-solve the initial condition without standing up a full computer-algebra system. Failed validation does not consume balance. Use dedicated tools for arithmetic sequences, infinite geometric series sums, and distribution probabilities when those are the real search intents; this capability exists only to recover a1 from term, n, and r.

What you can do with it

Back-solving initial conditions

Given a measured value at step n under fixed multiplicative gain r, recover the starting value without a full computer-algebra library.

FAQ

How do I find the first term of a geometric sequence?

Divide the known term by the common ratio raised to one less than its position. For a fifth term you divide by the ratio to the fourth power.

What is the first term if the fifth term is 162 and the ratio is 3?

The first term is 2. Three to the fourth power is 81, and 162 divided by 81 gives 2. Multiplying 2 by 3 four times takes you back to 162.

Why is a ratio of zero rejected?

With a ratio of zero, every term after the first is zero, so a later term tells you nothing about where the sequence started. Instead of inventing a value, the calculator rejects that case.

Can I use it for an arithmetic sequence?

No. An arithmetic sequence adds the same amount at each step instead of multiplying, so this back-calculation does not apply. Use a tool made for arithmetic sequences.

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

POSThttps://api.kit.forhosting.com/algebra/geometric-first-term

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/algebra/geometric-first-term \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"term":162,"r":3,"n":5}'

const res = await fetch("https://api.kit.forhosting.com/algebra/geometric-first-term", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "term": 162,
    "r": 3,
    "n": 5
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/algebra/geometric-first-term",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "term": 162,
    "r": 3,
    "n": 5
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/algebra/geometric-first-term", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"term":162,"r":3,"n":5}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"term":162,"r":3,"n":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/algebra/geometric-first-term", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "term": 162,
  "r": 3,
  "n": 5
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "algebra.geometric_first_term",
  "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

Per request$0.002

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 geometric sequence first term calculator applies the closed identity a1 equals a_n divided by r to the power n minus one, so a single deterministic call replaces pencil arithmetic that is easy to flip when exponents get large. The free browser path and the API path share one pure module, so classroom demos and production pipelines never disagree on the recovered starting term.

What recovering a1 means in a geometric progression

A geometric sequence is defined by a first term a1 and a common ratio r: each term after the first is the previous term multiplied by r, so the terms read a1, a1 times r, a1 times r squared, and so on. When n is greater than one, the ratio must be non-zero; otherwise the power of r is zero and division cannot recover a unique starting value. Negative ratios are allowed and produce alternating sequences; fractional ratios shrink terms toward zero when the absolute value of r is less than one. Infinite series sums and n-th term generation from a known a1 are out of scope on this page: the search intent here is specifically to find the first term from a later known term. The term in one-based position n is therefore a_n equals a1 times r to the power n minus one. When a textbook, spreadsheet, or sensor log hands you a_n, n, and r but not a1, you rearrange that identity: a1 equals a_n divided by r to the power n minus one. That is exactly what this geometric sequence first term calculator returns. When n is one, the known term is already the first term, the exponent is zero, any finite r yields a power of one, and first_term simply echoes the input term. The response echoes term, r, and n, reports first_term rounded for stable display, includes the intermediate ratio_power so learners can verify the division by hand, and states the formula string a1 equals a_n over r to the power n minus one.

Input contract, response shape, and validation rules

POST a JSON body with three required fields: term, the finite value of the known term a_n; r, the finite common ratio; and n, the one-based integer position of that term between one and ten thousand. Preferred names are term, r, and n; aliases an, a_n, known_term, and value map to term; ratio and common_ratio map to r; position, index, and k map to n. Numbers may arrive as JSON numbers or as plain decimal strings suitable for form posts and spreadsheet exports. Missing fields, empty strings, non-finite values, non-integer n, n below one, n above the published maximum, and r equal to zero when n is greater than one all fail with invalid_input and a message that names the problem. Those validation failures are not billed. On success the body includes the normalized term, r, and n; first_term as the recovered starting value; ratio_power as r to the power n minus one; formula as the recovery identity; and max_n so clients can validate batches before they send them. Example: term equals one hundred sixty-two, r equals three, n equals five yields first_term equals two, because two times three to the fourth equals one hundred sixty-two. Another example: term equals five, r equals one, n equals four yields first_term equals five, because every term equals a1 when the ratio is one. Pair this inverse recovery with a forward geometric sequence tool when you next need the n-th term or finite sum from a known first term; keep this endpoint focused on the first-term question so search intent and API contract stay clear.

Integration use cases

Homework and exam checks

Recover a1 when a worksheet gives a later term a_n, its position n, and the common ratio r, and verify answers against textbook methods.

LMS and auto-grading oracles

Mark geometric first-term items with a deterministic API that rejects invalid n or zero ratio after the first position.

Technical questions

How do I find the first term of a geometric sequence from a known term?

Send the known term a_n as term, its 1-based position as n, and the common ratio as r. The API returns a1 = a_n / r^(n-1).

What if n is 1?

When the known term is already the first term, first_term equals term and r^(n-1) is 1 for any finite r.

Can the common ratio be zero?

Only when n is 1. If n is greater than 1, r must be non-zero; otherwise the recovery divides by zero and the task fails with invalid_input.

How is this different from a geometric sequence calculator?

A forward calculator starts from a1 and produces a_n (and often the finite sum). This tool is the inverse: it recovers a1 from a known later term, n, and r.

What does the geometric sequence first term calculator cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free