How to Tell What Programming Language a Website Uses
To tell what programming language a website uses, open your browser’s Developer Tools and inspect the page’s HTTP response headers, cookies, and requests. A PHPSESSID cookie can point to PHP, X-Powered-By: Express can point to an Express service, and a JSESSIONID cookie can point to a Java servlet environment. The most useful result comes from matching those clues to the specific page or service that produced them. Manual
Start by deciding which part of the website you want to understand. A company’s homepage, customer dashboard, and checkout can use different backends even when they share a domain and look like parts of the same product. For a redesign or migration, knowing what powers the booking form can matter more than identifying the technology behind the homepage.
You can start with the free WebBuildFinder website technology checker, then verify the strongest clues in your browser. Here’s what to look for across PHP, JavaScript and Node.js, Python, Ruby, Java, .NET, and Go.
Why Backend Languages Are Difficult to Detect
Your browser receives the output of a website’s backend. For a page, that output might be HTML. For an API request, it might be JSON. A PHP application and a Python application can return identical HTML, and a Java service and a Go service can return the same JSON. View Page Source shows what the server delivered, so it can help you identify framework-generated markup and asset paths. The application code that generated the response typically stays on the server.
The response may also pass through several layers before reaching you. A content delivery network can serve cached HTML. A reverse proxy can route /blog/ to one application and /account/ to another. An API gateway can present one public address for several services. In each case, the headers you see can describe the layer that handled the request, while the application language remains hidden. Microsoft Learn
There’s another distinction worth making before you start. A language such as PHP or Python is different from a runtime such as Node.js, a framework such as Django, or a web server such as nginx. If you find a framework fingerprint, you can often infer the language ecosystem. If you find a web server header, you’ve learned something about how the request was served.
Start with the page that matters to your work. Open DevTools → Network, reload that page, and select the main Document request. Then use the site normally and review the Fetch/XHR requests related to the feature you’re investigating. Record the URL or hostname beside each clue. That small habit makes it much easier to explain why your findings differ across a website.
PHP
PHP is often easier to spot on websites that expose familiar CMS paths or use PHP’s default session cookie. If you see Set-Cookie: PHPSESSID=… on a response, you’ve found a useful clue. PHP documents PHPSESSID as the default session name and lets applications change it, so a site may use PHP and issue a differently named cookie. Manual
A visible .php URL, such as /contact.php or /index.php, can provide supporting evidence. Open the page through its normal navigation and check the final URL and headers. A site may preserve an old .php address after a migration so existing links and search results still work. The current response is more informative than the extension alone.
A CMS can give you a stronger starting point. For example, a blog that loads its own theme files from /wp-content/themes/ and also exposes other recognizable WordPress assets is likely backed by WordPress and PHP. Scope that result to the blog first. The main domain might have a custom frontend that uses WordPress to manage articles while a separate application handles customer accounts.
Example audit finding: “The blog loads WordPress theme assets and follows WordPress conventions. PHP is likely behind the blog’s CMS. The customer dashboard uses a separate hostname and requires its own check.”
JavaScript / Node.js
When you see .js files in the Network panel, you’ve found JavaScript sent to the browser. Many websites use browser JavaScript for menus, forms, analytics, and interactive features regardless of their backend. Node.js is a runtime for executing JavaScript outside the browser, so you need a signal tied to a server response to make a backend inference. Node.js Learn
A useful example is X-Powered-By: Express on the main document or a first-party API response. Express documents this header as an application setting, and developers can turn it off. When it appears on a request to api.example.com, it supports an Express finding for that API. The homepage and the rest of the site may use different software. A cookie such as connect.sid is a weaker clue that’s best interpreted alongside a framework signal. Express.js
Next.js requires an extra distinction. A page loading /_next/static/ files is exposing a framework clue. Next.js also supports static exports, so those assets can be delivered by a web server that serves static files. If your discovery question is whether Node.js is executing on each page request, the frontend assets alone leave that open. See How to Detect Next.js on a Website for a closer look at router markers, runtime clues, and deployment headers. nextjs.org
Python
Python backends may use Django, Flask, FastAPI, or other frameworks. Their public responses can look like conventional HTML pages or JSON APIs, so you’ll get further by looking for framework-specific conventions than by searching View Page Source for the word Python.
Django’s default cookie names provide a practical example. sessionid is its default session cookie name, and csrftoken is its default cookie name for cross-site request forgery protection. Either name can be changed. Since sessionid is a descriptive name that other applications can use, it carries more weight when the same service also sets csrftoken or exposes another Django clue in its normal page markup. GitHub
Imagine a site has a contact form that sets csrftoken. The login page on the same application sets sessionid. Together, those names are consistent with Django and give you a reasonable basis to report Python as likely for that application. If you see only sessionid on a separate identity provider’s hostname, keep your finding attached to that provider. The website’s own backend could be entirely different.
For a migration estimate, check which features appear to share the Python application. Forms, account pages, and content pages may call different services, and a reliable framework finding on one route won’t tell you how much of the site depends on that codebase.
Ruby
For public website research, Ruby on Rails is often the most recognizable route to a Ruby inference. Rails documents an application-specific session cookie key, with examples such as _your_app_session. A cookie named _customer_portal_session fits that style. Because the key is configurable and other frameworks can choose similar names, the pattern is best treated as supporting evidence. api.rubyonrails.org
Put that cookie in context. If the main account page sets it and the HTML also shows Rails-style form or CSRF conventions, you have more to work with than a cookie name on its own. If it only appears after the browser visits an embedded booking service, attribute the clue to the booking service’s response. The brand name in the cookie can feel convincing even when the application sits on a vendor’s subdomain.
A useful client-facing finding might read, “The account portal exposes a session cookie consistent with Rails. The backend language is unverified.” If the distinction affects who will maintain the project, ask for the repository’s Gemfile or the application’s dependency records. A deployed dependency list can tie Rails to the specific application more directly than public naming conventions can.
Java
A common Java ecosystem clue is the JSESSIONID cookie. The Jakarta Servlet specification defines JSESSIONID as the standard name for its session tracking cookie, so seeing it in a response supports a Java servlet environment for that application. Servlet applications can configure the cookie name, and some routes may have no reason to start a session. jakarta.ee
A .jsp route can provide another clue, especially if it’s part of an active user flow and the same application sets JSESSIONID. Some teams keep old URL patterns during a migration, so check what the current request returns. A redirect from an old .jsp address to a different application tells you the old URL is still supported. The destination response gives you the better evidence for the current stack.
Also consider what a Java ecosystem result covers. An application that runs in a servlet environment might contain Java alongside other JVM languages, such as Kotlin. If your audit is about modernization, list the publicly visible servlet evidence and ask which languages the deployed services use before estimating the work. For example, a customer portal can use a Java ecosystem authentication service while the product catalog and frontend are maintained separately.
.NET / C#
ASP.NET and ASP.NET Core fingerprints can help identify the .NET ecosystem. One useful clue is .AspNetCore.Session, the default cookie name when an ASP.NET Core application uses session middleware with the default naming configuration. An application can override the name, and it may only issue the cookie when it actually needs session state. Microsoft Learn
Older .aspx routes can point toward classic ASP.NET, particularly if the route is active and the response contains other matching clues. X-Powered-By: ASP.NET is worth checking, but Microsoft documents it as a default custom header in IIS 7 configuration and explains that IIS can supply it. A header applied by the hosting layer may appear on multiple types of responses. If the only result is Server: Microsoft-IIS, report IIS as the server clue and leave the application language open. Microsoft Learn
Does an ASP.NET Core cookie tell you the developers used C#? It supports a .NET framework finding. C# may be your working assumption for a project estimate, but check the project files or deployment records before listing it as a confirmed language. That matters when you’re taking over a legacy portal, where a shared hosting environment may contain several generations of applications.
Go
Go is hard to infer from a public response because a Go service can return the same HTML, JSON, cookies, and status codes you’d see from almost any backend. Its standard net/http package lets the application set cookies with names it chooses. A typical JSON response and a cookie called session give you little basis for a language conclusion. Go Packages
Suppose an API request returns Content-Type: application/json and Server: nginx. You can report that the endpoint returned JSON and that the response identifies nginx. The application behind it could be written in Go, Python, JavaScript, or another language. Fast responses and simple API URLs offer little help here because caching and deployment architecture can affect both.
For Go, an official engineering article about the specific service, a maintainer’s description, or the deployed project’s source and build records can be more informative than generic HTTP signals. If a company publicly says its image service is written in Go, attach that finding to the image service. You’ll need separate evidence to make the same claim about checkout or account management.
Cookies and Headers as Language Clues
The most reliable way to use cookies and headers is to check who set them and when. A cookie listed in browser storage may come from an earlier visit or a third-party integration. The Network panel shows the response where you observed Set-Cookie, so you can tie the clue to an exact request.
Public signalWhat it suggestsWhat to check nextPHPSESSIDPHP session handlingThe response that set it and any matching CMS or PHP route evidenceX-Powered-By: ExpressExpress frameworkWhether the header came from the main page, a first-party API, or an external widgetsessionid and csrftokenA pattern consistent with DjangoWhether both names belong to the same application_example_app_sessionA Rails-style session cookie nameOther Rails conventions on the response or pageJSESSIONIDA Java servlet environmentWhich application or route issued the cookie.AspNetCore.SessionASP.NET Core session middlewareThe application that issued it and any independent framework evidenceServer: nginxnginx in the delivery pathApplication-level evidence from that responseContent-Type: application/jsonA JSON responseA framework-specific clue tied to the API
To run a clean check in Chrome, open a private window, bring up DevTools → Network, and reload the page. Choose the main Document request and look under Response Headers for Server, X-Powered-By, and Set-Cookie. Next, select Fetch/XHR and check the requests the browser makes while you use the relevant feature. If the page redirects, look at the destination response as well.
In audit notes, record the cookie name and the response hostname. The cookie value adds little to language detection and can contain session data, so leave it out of shared reports. If the public homepage is heavily cached, repeat the check on a relevant public page that loads application data during normal use.
Never Treat One Signal as Proof
A single clue is a starting point. Even several matching clues can be misleading if they all came from a widget, redirect, or third-party service. Look for evidence from the page or application you’re assessing, then check whether a second type of signal supports the same conclusion.
Say your browser shows a React frontend, an nginx server header, and a PHPSESSID cookie. If the cookie came from the first-party account application, you can report PHP as likely for account handling. If the cookie came from a third-party support desk, the evidence belongs to that service. The visible React files describe the frontend either way. A migration estimate based on those findings should name the relevant component instead of assigning one language to the whole domain.
If you’re handing findings to a client, record the URL, observed signal, and confidence. A first-party response with matching framework and session clues supports a stronger conclusion. A generic cookie name or server header supports a more limited one. If your only evidence is cached HTML and browser JavaScript, “backend language could not be determined from public responses” is a valid audit result. When an exact answer affects scope or staffing, verify it against the repository, build configuration, or deployment records for that service.
To start your own check, enter the relevant URL into the WebBuildFinder website technology detector. Review the reported technologies, then confirm the strongest clues on the same URL in your browser. For a broader audit that also covers the CMS, hosting, and infrastructure, see How to Identify a Website’s Complete Tech Stack.
