Gov APIincometaxindia.gov.in ↗
Access 60+ years of Income Tax Department of India notifications via REST. Filter by year, search by keyword, paginate results, or bulk-fetch an entire year.
What is the Gov API?
This API provides structured access to official notifications published by the Income Tax Department of India, covering the years 1961 through 2026 — over six decades of regulatory data. Three endpoints let you discover available years with get_years, search and paginate notifications with get_notifications, or bulk-retrieve every notification for a given year with get_all_notifications_by_year. Each notification record includes its number, title, description, date, content type, and upload metadata.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/32ac21bb-58e6-45bd-ba0b-96553d77bea5/get_years' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace incometaxindia-gov-in-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: Income Tax India Notifications API — bounded, re-runnable."""
from parse_apis.income_tax_india_notifications_api import IncomeTaxIndia, YearCatalog, YearNotFound
client = IncomeTaxIndia()
# Discover available years (single catalog object)
catalog = client.yearcatalogs.get()
print(catalog.total, catalog.years[:5])
# Search notifications with keyword filter, capped
for notif in client.notifications.search(search="Deduction", limit=3):
print(notif.notification_number, notif.notification_date, notif.content_type)
# Drill-down: take one notification from a specific year
notif = client.notifications.search(year="2025", limit=1).first()
if notif:
print(notif.title, notif.categories)
# Bulk-fetch a year's notifications (capped for demo)
for item in client.notifications.list_by_year(year="2026", max_pages=1, limit=5):
print(item.notification_number, item.notification_date, item.document_title)
# Typed error handling
try:
result = client.notifications.search(year="9999", limit=1).first()
except YearNotFound as exc:
print(f"Year not available: {exc.year}")
print("exercised: yearcatalogs.get / notifications.search / notifications.list_by_year / YearNotFound error")
Retrieve the complete list of years for which notifications are available. Returns year strings from 1961 through the current year. Useful for discovering valid year values before filtering notifications.
No input parameters required.
{
"type": "object",
"fields": {
"total": "integer count of available years",
"years": "array of year strings (e.g. '1961', '2024')"
},
"sample": {
"data": {
"total": 66,
"years": [
"1961",
"1962",
"2024",
"2025",
"2026"
]
},
"status": "success"
}
}About the Gov API
What the API Covers
The API surfaces notifications from incometaxindia.gov.in, the official portal of India's Income Tax Department. Coverage spans from 1961 to the current year. Each notification object returned includes title, description, notification_number, summary, content_type, notification_date, and upload fields — giving you both the identifying metadata and document references for each record.
Endpoints and Parameters
get_years takes no inputs and returns a years array of strings alongside a total count, making it the right first call when you need to validate a year value before filtering. get_notifications accepts four optional parameters — page, year, search, and page_size — and returns pagination metadata (page, last_page, total_count, page_size) alongside the notifications array. Omitting all filters returns notifications across all available years. The search param lets you filter by keyword within notification titles or content.
Bulk Year Retrieval
get_all_notifications_by_year is designed for full-year archival work. It requires a year string and accepts optional max_pages and page_size controls. Internally it handles pagination and returns total_count (the reported total for the year) alongside fetched_count (the number actually collected). The max_pages parameter acts as a safety cap to prevent runaway iteration on years with large volumes of records.
Data Freshness and Scope
Notifications reflect what is publicly available on incometaxindia.gov.in. The dataset includes income tax circulars, statutory notifications, and departmental orders published across decades. The notification_date and upload fields allow you to sort or filter by recency on the client side after retrieval.
The Gov API is a managed, monitored endpoint for incometaxindia.gov.in — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when incometaxindia.gov.in changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official incometaxindia.gov.in API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Building a searchable archive of Income Tax Department notifications for tax professionals and researchers
- Monitoring new notifications by year to track regulatory changes in Indian income tax policy
- Extracting all notifications for a specific year using
get_all_notifications_by_yearto populate a local database - Keyword searching notifications via the
searchparam to find rules related to specific sections or topics like TDS or exemptions - Displaying notification timelines by year using
get_yearsto drive a year-selector UI - Comparing notification volumes across decades using
total_countdata returned per year - Automating alerts when new notifications appear by periodically querying recent years and checking for new
notification_numbervalues
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does the Income Tax Department of India provide an official developer API?+
What does the `get_notifications` endpoint return, and how does filtering work?+
title, description, notification_number, summary, content_type, notification_date, and upload. You can filter by year (e.g. '2023'), by keyword using the search param, or control page size with page_size. Omitting all filters returns notifications across all years. The response always includes total_count and last_page for pagination navigation.Does the API expose the full text or PDF content of each notification?+
title, description, summary, notification_number, notification_date, content_type, and upload — but not the full parsed text body or a resolved document download URL. You can fork this API on Parse and revise it to add an endpoint that fetches and returns the full document content for a given notification.Are there any years with incomplete or sparse data?+
fetched_count field in get_all_notifications_by_year will reflect exactly how many records were available for any given year, which may be less than expected for older periods.Can I retrieve notifications filtered by category or content type?+
get_notifications endpoint does not currently accept content_type or category as a filter parameter. The content_type field is present in each returned notification object, so you can filter client-side after retrieval. You can fork this API on Parse and revise it to add server-side filtering by content type or category.