railradar.in

RailRadar (railradar.in) is a web platform for tracking Indian Railways trains on a live GPS map, checking 14-day IRCTC seat availability forecasts, calculating itemized fares, and verifying PNR status. Use it when you have a train number or name, a journey date and class, or a 10-digit PNR — no app install is described in the source material, and the site presents itself as a browser-based tool. The steps below follow the three workflows RailRadar documents on its own site.

Track a Live Train Location

1. Enter your 5-digit train number or train name in the search box.
2. Open the result to view the train's real-time location, speed, delays, and upcoming platform numbers.

What you get back, per RailRadar's feature description:

• Live GPS position plotted on an interactive map (not a static list of passed stations)
• Current train speed and running delay
• Coach position and platform numbers for upcoming stations

RailRadar states it aggregates crowdsourced GPS telemetry with official Indian Railways PRS synchronization. That combination is the reason the map view and the official status can differ slightly in timing — treat the map as the live position and PRS-synced data as the authoritative record for delays and platforms.

Check Seat Availability and Fares

1. Select your train.
2. Enter your travel stations and journey date.
3. Choose your class.

RailRadar then shows:

The fare breakdown is itemized into base fare, superfast charges, reservation fees, GST, and catering, so you can see what makes up the total rather than a single number.

Verify PNR Status

Enter your 10-digit PNR to check:

• Real-time booking status
• Confirmed coach and berth numbers
• A machine-learning confirmation probability for waitlisted tickets

The confirmation probability is a prediction, not a guarantee — it is generated by a model, so treat it as one input alongside your own buffer for travel plans.

Check the Live Station Board

Use the live station board to see upcoming train arrivals and departures across India for a station. This is useful when you are at or heading to a station and want to know what is arriving next, rather than tracking one specific train.

Search Trains Between Stations

If you have not picked a train yet, search all available trains running between any two stations. Results include route-scoped halting schedules and live timetables, which is the right starting point when you know your origin and destination but not the train number.

For Developers: REST API

RailRadar offers a developer REST API covering live coordinates, seat availability, timetables, and high-density GeoJSON route geometry. According to the site, it launches with a free sandbox offering 1,000 requests per month, with API documentation and a developer portal linked from the site. Check the pricing page for any paid tiers beyond the sandbox — the source material does not list prices.

Common Points to Watch

• Train number format: the search expects a 5-digit train number or a train name. A partial or mistyped number will not resolve.
• Class and quota both matter: availability differs by class and by quota (General, Tatkal, Ladies), so a seat showing open in one quota may not be open in another.
• Forecast vs. live booking: the 14-day availability is a forecast view; the actual IRCTC booking window is what confirms your ticket.
• PNR probability is a model output: use it as guidance, not as confirmation.

Quick Reference

To check a train's live running status on RailRadar, enter its 5-digit train number or name in the search box, then confirm the train and journey date. The result shows the train's real-time GPS location on a map, its current speed and delay, upcoming platform numbers, and coach position. This works for trains that have already started their journey; a train that hasn't departed yet will show its scheduled timetable rather than live movement. RailRadar aggregates crowdsourced GPS telemetry with Indian Railways PRS synchronization to produce these updates.

Step 1: Find the right train

1. Enter the 5-digit train number (for example, the number printed on your ticket) or the train name in the search box.
2. From the results, select the exact train. Many routes share similar names, so check the source and destination stations before tapping.
3. Confirm the journey date. A train number alone can map to different runs on different days, and picking the wrong date gives you the wrong live position.

Expected result: you land on that train's live status page for the correct day.

Step 2: Read the live status output

Once the train page loads, you'll see several live fields:

The map view plots the train geographically, while the station list shows passed and upcoming halts in order. Use the map when you want to see how far the train physically is from your station; use the station list when you want arrival/departure times and platform numbers at each halt.

Step 3: Check platform and coach details for arrival

Before you leave for the station, look at:

• Platform number for your boarding or receiving station — this can change, so recheck close to arrival.
• Coach position — confirms where your coach will stop, useful at long platforms.
• Live station board — shows upcoming arrivals and departures across a station, handy when you're meeting someone rather than tracking one train.

Common problems and how to handle them

• No data showing. The train may not have started its journey yet, or telemetry hasn't synced. A not-yet-departed train shows its schedule, not live movement.
• Wrong train. You likely picked a same-named train on a different route or the wrong date. Re-select using the 5-digit number and verify source/destination.
• Stale or frozen updates. Crowdsourced GPS can lag in low-signal stretches. Cross-check the delay figure against the station list; if both look frozen, refresh.
• Delay looks wrong. Compare the running delay with the last/next station timings — a large gap between them usually means the delay figure is mid-update.

What else you can check on the same page

RailRadar bundles related tools so you don't need a second site:

• 14-day IRCTC seat availability across Sleeper, 3rd AC, 2nd AC, 1st AC, and Chair Car, for General, Tatkal, and Ladies quotas.
• Fare calculator with an itemized breakdown (base fare, superfast charges, reservation fees, GST, catering).
• PNR status and prediction — real-time 10-digit PNR status, confirmed coach and berth, and a confirmation probability.
• Trains between stations with route-scoped halting schedules.

If you're building this into an app, RailRadar offers a developer REST API for live coordinates, seat availability, timetables, and GeoJSON route geometry, with a free sandbox of 1,000 requests per month. Paid plan details are on the site's pricing page.

If you're new to Ahrefs and want to run your first SEO audit, the fastest path is: open Site Explorer, enter your target URL, review the Overview for a health snapshot, then dig into Organic Keywords, Top Pages, and Site Audit to find specific problems. From there, build a short prioritized to-do list instead of trying to fix everything at once.

This tutorial walks through that workflow using a realistic starting scenario, explains what the numbers mean, and shows how to turn findings into actions.

Before You Start: Pick a Narrow Scope

A common beginner mistake is auditing an entire large website on day one. The reports become overwhelming, and you can't tell which issues matter.

Instead, choose one of these starting points:

• A single important page (your homepage or a key product/service page)
• A small site (under ~50 pages, e.g., a personal blog or small business site)
• One section of a bigger site (e.g., /blog/)

For this tutorial, assume you're auditing a small business site with about 30 pages. The same steps scale up later.

You'll need an Ahrefs account to follow along. Ahrefs offers paid plans, and pricing and feature limits change over time, so check the current Pricing page for what's included in each tier before committing.

Step 1: Enter Your Target in Site Explorer

Site Explorer is Ahrefs' core tool for analyzing any website or URL.

1. Open Site Explorer from the top navigation.
2. In the search box, paste your domain (e.g., example.com).
3. Choose the Exact URL or Domain mode depending on scope. For a full-site view, use Domain or Prefix; for a single page, use Exact URL.
4. Press Enter.

You'll land on the Overview report. Don't try to absorb everything — focus on four numbers first.

Reading the Overview Snapshot

Important caveat: Ahrefs' traffic and keyword numbers are estimates based on its own data. They won't match Google Search Console or your analytics exactly. Treat them as directional, not absolute.

Step 2: See What You Already Rank For

Go to Organic Keywords in the left sidebar. This shows queries where your site appears in search results.

Sort by Traffic (descending) to see which pages bring the most estimated visitors. Then look for:

• Keywords ranking in positions 4–15 — these are often the easiest wins. A small content or on-page improvement can push them onto page one.
• Keywords with high volume but low position — potential opportunities if the topic is relevant.
• Irrelevant keywords — if you rank for something off-topic, it may signal thin or mismatched content.

Write down 5–10 of the position 4–15 keywords. These become your first optimization targets.

Step 3: Find Your Best and Weakest Pages

Open Top Pages. This ranks your URLs by estimated organic traffic.

Look for two things:

1. Your top performers — understand what topics and formats work. Can you create more content like this?
2. Pages with traffic but poor rankings — these may need on-page fixes (title, headings, internal links).

If a page gets zero traffic and targets a topic you care about, it's a candidate for a rewrite or consolidation.

Step 4: Run a Technical Site Audit

Now move to Site Audit. This crawls your site and flags technical and on-page issues.

1. Click Site Audit → New project.
2. Enter your domain and set crawl settings (default is usually fine for a small site).
3. Start the crawl and wait for it to finish.

Once complete, you'll see a Health Score and a list of issues grouped by category.

Which Issues to Fix First

Not all issues are equal. Prioritize in this order:

Ignore low-impact warnings (like minor meta description length) until the big items are handled.

Step 5: Turn Findings Into a To-Do List

You now have raw data. Convert it into a short, actionable list. Example:

1. Fix 3 broken links found in Site Audit.
2. Rewrite title tags on 5 pages with duplicate titles.
3. Improve 4 pages ranking in positions 6–12 by adding missing subtopics and internal links.
4. Remove or update 2 thin pages with no traffic.

Keep the list to 5–10 items max for your first audit. Finishing a short list beats starting a long one.

Common Beginner Mistakes

• Chasing every red flag. Site Audit flags many minor issues. Fix what affects rankings and users first.
• Trusting estimates as exact numbers. Ahrefs data is modeled, not measured from your analytics.
• Auditing a huge site too early. Start small to learn the interface.
• Ignoring search intent. A page can be technically perfect but still fail if it doesn't match what searchers want.
• Forgetting to re-crawl. After fixes, run Site Audit again to confirm improvements.

Where to Go Next

Once your first audit is done:

• Compare with competitors using Site Explorer's Competing Domains and Content Gap reports.
• Track keyword rankings over time with Rank Tracker.
• Explore backlink opportunities in the Backlinks and Link Intersect reports.
• Set up recurring Site Audit crawls so new issues surface automatically.

Your first audit isn't about perfection — it's about building a repeatable habit: enter a target, read the key reports, pick the highest-impact fixes, and act. Do that once a month and your site's health compounds.

OpenAPI-generated API documentation is reference documentation that is produced automatically from an OpenAPI description file rather than written by hand. You write (or generate) a machine-readable specification of your API — endpoints, parameters, request bodies, responses, schemas, and auth — and a documentation tool reads that file and renders a browsable, often interactive reference site. The spec becomes the single source of truth; the docs become a build artifact.

This differs from manually written docs in one fundamental way: with hand-written docs, the prose is the source of truth and the API is described separately. With spec-driven docs, the API description is the source, and every page, table, and code sample is derived from it.

How the workflow actually runs

A typical spec-driven documentation pipeline has five stages:

1. Author or generate the spec. You either write an OpenAPI document by hand (YAML or JSON), or generate it from code annotations, framework metadata, or a design-first editor. Design-first means the spec is written before implementation; code-first means it is extracted from existing code.
2. Validate and lint. The spec is checked against the OpenAPI schema and against style rules — consistent naming, required descriptions, no undocumented 4xx responses, no orphaned schemas.
3. Bundle and transform. Multi-file specs are combined, $ref pointers are resolved, and the document is optionally split into per-tag or per-version outputs.
4. Render. A documentation tool converts the spec into HTML: an endpoint list, a sidebar of operations, parameter tables, response schemas, and a "try it" console.
5. Publish and version. The rendered site is deployed, and each API version gets its own snapshot so consumers can read docs matching the version they call.

Steps 2 through 5 are usually automated in CI. If the spec fails validation, the docs build fails — which is the point.

Spec-driven vs. hand-written documentation

The practical conclusion most teams reach: generate the reference, write the guides. Reference material is repetitive and mechanical, which is exactly what generation is good at. Conceptual explanations, migration notes, and tutorials carry judgment that a spec cannot express.

What you get out of the box

Generated reference pages commonly include:

• An operation list grouped by tag or path, with HTTP method and path.
• Parameter tables showing name, location (path, query, header, cookie), type, required flag, and description.
• Request and response schemas rendered as expandable trees, including nested objects and arrays.
• Authentication details pulled from the securitySchemes section.
• Interactive request consoles that let a reader send a real call from the browser.
• Generated code samples in several languages, derived from the same schemas.
• Multiple output formats, such as a static site, a single HTML file, or a mock server.

Because all of these come from one document, changing a field name in the spec updates the parameter table, the schema tree, and every code sample at once.

Where spec-driven documentation breaks down

Generation is not free. The trade-offs are real:

Spec quality becomes documentation quality. A field with no description produces a table row with an empty cell. A vague summary produces a vague heading. Tools can enforce presence of descriptions via linting, but they cannot enforce that the description is useful.

Customization has limits. If you need a page that does not map to an OpenAPI concept — a conceptual overview, a pricing explanation, a comparison of two endpoints — you write it outside the generator and link to it.

Not everything is expressible. Webhooks, streaming responses, long-polling behavior, and complex multi-step flows are awkward or impossible to describe fully in OpenAPI. Those need prose.

The spec can go stale. If the spec is maintained separately from the implementation, it drifts just like hand-written docs. The mitigation is to generate the spec from code, or to test the implementation against the spec in CI.

Interactive consoles need care. A "try it" button that hits a production API with real credentials is a security and rate-limit problem. Point it at a sandbox, or disable it.

Deciding whether to adopt it

Adopt spec-driven reference documentation if most of these are true:

• Your API has more than a handful of endpoints, or changes frequently.
• You ship client SDKs or code samples in more than one language.
• Multiple teams consume the API and need a consistent, always-current reference.
• You already have, or are willing to maintain, an OpenAPI description.

Stay with hand-written docs, or a hybrid, if:

• Your API is small and stable, and the reference fits on one page.
• Your documentation is mostly conceptual and contains little endpoint-level detail.
• You cannot commit to keeping the spec in sync with the implementation.

A reasonable middle path: generate the reference from the spec, and hand-write the getting-started guide, authentication walkthrough, and error-handling page. Link the two directions so readers can move from concept to endpoint and back.

A minimal starting checklist

1. Produce one valid OpenAPI document for a single API version.
2. Add a linter with rules for descriptions, operation IDs, and error responses.
3. Wire the docs build into CI so a failing spec fails the build.
4. Render the reference and review it as a reader, not as the author.
5. Write the two or three conceptual pages the generator cannot produce.
6. Version the published docs alongside the API version.

The core idea is simple: describe the API once, in a format both machines and humans can read, and let the reference documentation fall out of that description. Everything else — tooling, hosting, interactivity — is a detail on top of that decision.