Website profiles · Technology insights · Alternatives

js.org No paid content found

Categories: Social & Community Development

Tags: js.org

Dedicated to JavaScript and its awesome community since 2015

Visit website

Updated: 2026-09-30 07:56 Language: English (default) Access: Normal

Profile views 3 Outbound visits 0
JS.ORG Full homepage screenshot
Editorial Review

Website Review

What is JS.ORG?

JS.ORG is a free subdomain service for JavaScript projects, run since 2015. It gives you a clean URL such as yourproject.js.org that points at a GitHub Pages site you already control. You keep ownership of the repository and its content; JS.ORG only provides the domain name.

The main catch is the content requirement: your page must have a clear connection to JavaScript. A personal portfolio, a library demo, documentation, or a small tool all fit. An unrelated blog or a parked page does not.

How it works

  1. Create or open a GitHub Pages site and add real content.
  2. Pick a subdomain based on your GitHub username or repository name — for foo.github.io/bar, either foo.js.org or bar.js.org is possible.
  3. Add a CNAME file to the repo (in the gh-pages branch for project pages) containing just the chosen domain.
  4. Open a pull request adding your subdomain to the JS.ORG domain list. It typically goes live within 24 hours, though naming conflicts can slow things down.

Who it suits

  • Library and tool authors who want a memorable docs or demo URL without buying a domain.
  • Students and hobbyists publishing a first JavaScript project.
  • Maintainers of small open-source projects who want something shorter than a github.io address.

It suits you less if you need full DNS control, email on the domain, or a name unrelated to your GitHub account or repo. For those, a registered domain is the better route.

Trade-offs to weigh

JS.ORG subdomain Own domain
Cost Free Registration and renewal fees
DNS control Limited to the subdomain Full
Naming Tied to username or repo name Anything available
Portability Stays with JS.ORG Yours to move

Next step

If your project is JavaScript-related and already on GitHub Pages, check whether your username or repo name gives you a subdomain you would be happy to share. If the name is awkward or you expect to outgrow GitHub Pages, register your own domain instead. Either way, read the JS.ORG terms first, since as the repository owner you carry responsibility for everything published under the subdomain.

How do I get a free .js.org subdomain for my GitHub Pages project?

You get a free *.js.org subdomain by hosting your project on GitHub Pages and then asking JS.ORG to point one of its subdomains at it. JS.ORG doesn't host your files; it provides the custom URL, while GitHub Pages serves the content. JS.ORG

The four-step process

  1. Set up a GitHub Pages site on your GitHub account and publish real content. The page should have a clear connection to JavaScript — a library, tool, demo, documentation or project page qualifies; an unrelated personal blog does not.
  2. Pick the subdomain name. It must match either your GitHub username or your repository name. For a Pages URL like http://foo.github.io/bar, you can request foo.js.org or bar.js.org.
  3. Add a file named CNAME to your repository (in the gh-pages branch for project pages) containing a single line with the chosen domain, such as foo.js.org — no quotes, no extra text.
  4. Open a pull request in the JS.ORG GitHub repository to add your subdomain to the list of existing domains. The new URL typically goes live within 24 hours, so watch the pull request in case of a naming conflict or a follow-up question.

Practical things to know

  • You keep full control of your published content, and with that comes responsibility for it — including the legal and editorial duties of running a public site.
  • The main trade-off is the naming constraint: you can't pick an arbitrary brand name unless it happens to be your username or repo name. If you want mycoolproject.js.org but the repo is called something else, rename the repo or accept the alternative.
  • Conflicts are possible. Popular usernames and repo names may already be taken, which is why the pull request step exists as a check rather than an automatic approval.
  • A .js.org URL signals to other JavaScript developers that the project is relevant to them, which is useful for libraries, CLI tools and small documentation sites. It is less suitable for a commercial product that needs its own brand domain.

A concrete example

Suppose your GitHub username is ada and you publish a small date-parsing library at https://ada.github.io/dateparse. You could request ada.js.org or dateparse.js.org. If dateparse.js.org is already claimed, ada.js.org still works, and you can link to the specific project path from your README.

Next step

Before starting, check whether your preferred name is already in the JS.ORG domain list. If it is, choose the other option (username or repo name) and proceed with the CNAME file and pull request. If you'd rather use a domain you fully own, GitHub's own custom domain documentation is the alternative path.

What content does my page need to qualify for a JS.ORG subdomain?

Your page needs "reasonable content with a clear connection to JavaScript," per JS.ORG's own description. In practice that means the site should be recognizably about JavaScript or built for the JavaScript community — a library, framework, tool, demo, documentation site, tutorial collection, or a personal developer page centered on JS work. A generic blog, portfolio, or business page with no JS angle is the kind of thing likely to draw a question on your pull request.

A few practical points from how the process works:

  • The subdomain is tied to a GitHub Pages site, so the content has to actually be live there before you request the URL.
  • You choose the name from your existing GitHub Pages URL — for foo.github.io/bar, either foo.js.org or bar.js.org works.
  • JS.ORG reviews the pull request that adds your subdomain, and naming conflicts or content questions are raised there. That review is where the "clear connection to JavaScript" test gets applied.

A concrete test: if a visitor landed on your page knowing nothing about you, would they immediately see why it belongs under a JavaScript domain? A project README-style page for a JS library passes easily. A page about your photography hobby does not, even if you wrote it in JavaScript.

Next step: before opening the pull request, write one sentence describing the JS connection and check whether the page itself makes that obvious within the first screen. If it doesn't, add a short description or link to the related repository. Note that you keep full control and full responsibility for what you publish — JS.ORG states that publishing rights and duties stay with you.

If you want a subdomain without that content constraint, a general free host is a better fit; JS.ORG's value is the JS-specific URL, and the content rule is the price of it.

Can I use my GitHub username or repository name as the subdomain?

Yes. JS.ORG lets you derive the subdomain from your existing GitHub Pages URL, so you can use either your GitHub username or your repository name.

According to the site's own instructions, if your GitHub Pages URL is http://foo.github.io/bar, then either foo.js.org or bar.js.org is possible. In other words:

  • Username-based: foo.js.org — good when the project is tied to you personally or when you want one recognizable namespace across several repos.
  • Repo-based: bar.js.org — good when the project has its own identity and might later move or be handed to someone else.

How to set it up

  1. Create or open your GitHub Pages site and make sure it has real content clearly related to JavaScript.
  2. Pick your subdomain based on the existing Pages URL, as above.
  3. Add a file named CNAME to your repo (in the gh-pages branch for project pages) containing a single line with your chosen domain, such as foo.js.org.
  4. Open a pull request on the JS.ORG repository adding your subdomain to the list of existing domains.

The site says the new URL should go live within 24 hours, and advises watching your pull request in case of a naming conflict or a follow-up question.

What to weigh before choosing

Choice Best for Trade-off
Username subdomain Personal portfolios, multiple small projects Name is tied to your account; less fitting if the project grows beyond you
Repo subdomain A single named project or library Renaming the repo later may mean redoing the subdomain request

One practical point: the subdomain has to match part of your current GitHub Pages URL, so decide before you publicize the address. If you expect the project to outlive your involvement, the repo name usually ages better.

As a next step, check whether the name you want is already taken in the JS.ORG domain list before you write your CNAME file — that avoids doing the work twice if there's a conflict. You keep full control over the published content, but the site notes that responsibility for what you publish stays with you.

How long does it take for a new JS.ORG subdomain to go live?

A new JS.ORG subdomain typically goes live within 24 hours of your pull request being accepted. The site states this directly: after you add your subdomain to the JS.ORG list via a pull request, "Your new URL should go live within 24 hours."

Two practical points worth knowing:

  • The 24-hour window starts after your pull request is processed, not when you first create the GitHub Page or add the CNAME file.
  • The site advises keeping an eye on your pull request in case of a naming conflict or a question from the maintainers. A conflict can delay things beyond that window, so respond promptly if asked.

What to do while you wait

Set up your GitHub Page content and CNAME file first, then open the pull request. If the subdomain is a priority, check the pull request after a day; if there's no response or a conflict is flagged, address it directly in the thread rather than opening a new request.

For background on the service, see JS.ORG.

Who owns and controls the content published on a JS.ORG subdomain?

The repository owner keeps complete control over the content published on a JS.ORG subdomain. JS.ORG itself does not take editorial control or ownership of your page: it approves the subdomain name and points it at your GitHub Pages site, while you remain responsible for everything you publish and for the rights and duties that come with running a public website.

In practice, that split looks like this:

  • You control: the site's files, text, images, design and updates, held in your own GitHub repository.
  • JS.ORG controls: the subdomain namespace, meaning it decides whether your requested name is granted and whether it stays in the domain list.
  • You are responsible: copyright, licensing, privacy notices and legal compliance for the published content.

A useful next step if you are considering this: treat the subdomain as a naming privilege rather than a hosting service. Before applying, make sure your page has clear, reasonable JavaScript-related content, pick a subdomain name that matches your existing GitHub Pages URL, and add a CNAME file to your repository with that single domain line. Then open a pull request adding your subdomain to the JS.ORG list.

One practical decision criterion: choose a JS.ORG subdomain when you want a short, memorable JavaScript-flavoured URL on top of GitHub Pages and you are comfortable managing content yourself. If you need guaranteed uptime, a custom domain you fully own, or hosting beyond static pages, a different setup may suit you better. The trade-off is simple — you get a sleeker address and community recognition, but ownership of the content, and the obligations attached to it, stay entirely with you.

Related questions

More questions →
What is JS.ORG?

JS.ORG is a service that gives JavaScript projects a free *.js.org subdomain, typically pointed at a site hosted on GitHub Pages. It has been run for the JavaScript community since 2015. You qualify if your page has "reasonable content with a clear connection to JavaScript" — a personal portfolio or an unrelated project won't pass. The subdomain is free, but you keep full responsibility for the content you publish.

What you actually get

A short, recognizable URL instead of the default GitHub Pages address. For a repo served at http://foo.github.io/bar, you can claim either foo.js.org or bar.js.org, since the subdomain can match your GitHub username or your repository name.

The trade-off is that JS.ORG only supplies the name and the DNS routing. Hosting, content, and legal responsibility stay with you as the repository owner.

How to get a subdomain

The process is four steps, all built around an existing GitHub Pages site:

  1. Set up your GitHub Page. Log in to GitHub and publish a page following GitHub's instructions, with real JavaScript-related content already in place.
  2. Pick your subdomain. Choose either your username or your repo name, based on your existing GitHub Pages URL. The JS.ORG wiki covers the naming details.
  3. Add a CNAME file. Put a file named CNAME in your repo — in the gh-pages branch for project pages — containing a single line with your chosen domain, e.g. foo.js.org with no quotes. GitHub's "Custom URLs" help section covers problems here.
  4. Open a pull request. Submit a PR to the JS.ORG GitHub repository adding your subdomain to the list of existing domains.

Your new URL should go live within 24 hours. Watch your pull request during that window — JS.ORG may flag a naming conflict or ask you a question before merging.

Things that commonly go wrong

  • No content yet. Applying before your page has substantive JavaScript-related content is the most likely reason to be turned down.
  • Wrong branch. For project pages, the CNAME file belongs in gh-pages, not the default branch.
  • Formatting in CNAME. A stray quote, extra line, or trailing path will break the custom domain mapping.
  • Name collisions. If someone already holds the subdomain you want, expect a back-and-forth on the pull request.

Who should use it

JS.ORG fits JavaScript developers who already have a GitHub Pages site and want a cleaner, more memorable address for it — a library docs page, a project demo, or a personal JS-focused site. It's a poor fit if your content isn't clearly about JavaScript, if you need custom hosting outside GitHub Pages, or if you want a provider to handle content liability for you.

Should I choose my GitHub username or my repository name as my JS.ORG subdomain?

Both are allowed. The choice depends on how your existing GitHub Pages URL is structured, and on which name better represents the site you are publishing.

JS.ORG accepts a subdomain that matches either the username or the repository name in your GitHub Pages URL. For a page at http://foo.github.io/bar, either foo.js.org or bar.js.org is possible. Once you pick one, that exact name has to appear in your CNAME file and in your pull request.

How the GitHub Pages URL maps to your options

GitHub Pages URLs follow the pattern username.github.io/repo. JS.ORG draws its allowed subdomains from the two name segments in that URL.

Your GitHub Pages URL Possible JS.ORG subdomains
foo.github.io/bar foo.js.org or bar.js.org
foo.github.io (user site) foo.js.org

For a user site (username.github.io with no repository path), the username is the only segment available, so the subdomain choice is effectively made for you.

When the username is the better pick

  • The site is personal — a portfolio, blog, or profile — rather than a single project.
  • You plan to host several projects under one identity and want one recognizable address.
  • Your username is short, memorable, and already how people find you on GitHub.

A username-based subdomain stays meaningful even if you rename or replace the underlying repository later, since the address points at you rather than at one project.

When the repository name is the better pick

  • The site is a single project, library, or tool with its own name.
  • The repository name is more descriptive than your username (for example, a library called bar under a generic username).
  • You want the URL to read like the product, not like the author.

A repository-based subdomain is the natural fit when the project name is the thing people will search for or share.

What to weigh before deciding

  • Recognizability. Which name will someone remember after seeing it once?
  • Fit with the topic. Does the name signal what the page is about?
  • Consistency. The name you choose must match in three places: the CNAME file, the pull request, and the domain you actually want. A mismatch is a common reason a request stalls.
  • Conflicts. Names are not guaranteed to be free. If your first choice is already taken, the other segment from your URL is your built-in fallback.

The step that locks in your choice

After deciding, add a file named CNAME to your repository — in the gh-pages branch for project pages — containing a single line with the chosen domain, for example foo.js.org without quotes. Then open a pull request in the JS.ORG GitHub repository adding your subdomain to the list of existing domains. Your new URL should go live within 24 hours, so keep an eye on the pull request in case of a naming conflict or a question from the JS.ORG side.

If you are unsure, the repository name is usually the safer default for a project site, and the username for a personal site. Either way, the decision is reversible only by going through the process again, so pick the name you would be happy to keep.

What to Do If Your JS.ORG Subdomain Request Has a Naming Conflict or Doesn't Go Live

JS.ORG subdomains are requested by pull request, and the site states your new URL should go live within 24 hours. If it doesn't, the cause is almost always one of three things: a naming conflict, a missing or misplaced CNAME file, or a GitHub Pages custom domain setting that wasn't completed. Work through the checks below in order, and respond on your pull request if the maintainers raise a question.

First, confirm what "not live" means

Before changing anything, separate the two possible states:

  • Your pull request is still open or has comments. The request hasn't been merged, so nothing should be live yet. Go to the pull request and read the maintainers' comments.
  • Your pull request was merged but the URL still doesn't resolve. This points to a DNS or GitHub Pages configuration problem on your side, not a JS.ORG problem.

The site notes you should keep an eye on your pull request in case of a naming conflict or a question from the JS.ORG side, so the pull request is the first place to look.

Handling a naming conflict

A conflict happens when the subdomain you picked is already taken or clashes with an existing JS.ORG domain.

  1. Open your pull request and read the maintainers' comment identifying the conflict.
  2. Choose an alternative subdomain. Per the site, for a GitHub Pages URL like http://foo.github.io/bar, either foo.js.org or bar.js.org is possible — so if one is taken, the other is usually a valid substitute. The wiki linked from the site has more detail on eligible names.
  3. Update the CNAME file in your repository to match the new name exactly (see below).
  4. Update the subdomain entry in your pull request so it matches the new CNAME value.
  5. Reply on the pull request confirming the change, then wait for it to be merged.

If the maintainers ask a question rather than flagging a conflict, answer it directly on the pull request — an unanswered question is itself a reason the request stalls.

Check the CNAME file

This is the most common self-inflicted failure. The site's step 3 is specific about the requirements:

  • The file must be named exactly CNAME (no extension).
  • It must contain a single line matching your chosen domain, for example foo.js.org, written without quotes.
  • For project pages, it must be added to the gh-pages branch, not the default branch.

If your CNAME has a trailing slash, quotes, extra whitespace, or the wrong domain, GitHub Pages won't serve the custom domain correctly. Fix the file, commit it to the correct branch, and give GitHub a few minutes to rebuild.

Verify the GitHub Pages custom domain setting

The CNAME file and the repository's Pages settings need to agree. In your repository's GitHub Pages settings, confirm the custom domain field shows the same domain as your CNAME file. GitHub's own "Custom URLs" documentation, which the site points to for troubleshooting, covers the exact steps for your account type. If the field is empty or shows a different domain, set it to your JS.ORG subdomain and save.

If the pull request was merged but the URL is still dead

Work through this sequence:

  1. Wait out the window. The site says the URL should go live within 24 hours of the request being handled. Check again after that period before assuming something is broken.
  2. Re-check the CNAME file on the branch GitHub Pages actually serves. A file committed to the wrong branch has no effect.
  3. Re-check the Pages custom domain setting and re-save it if needed — saving triggers GitHub to re-verify the domain.
  4. Confirm the pull request was actually merged, not just approved or closed. Only a merged request adds your subdomain to the JS.ORG domain list.
  5. If all of the above are correct and 24 hours have passed, comment on the merged pull request describing what you've verified (CNAME contents, branch, Pages setting, time elapsed). That gives the maintainers the information they need to investigate.

What JS.ORG does and doesn't control

Worth keeping in mind while troubleshooting: JS.ORG provides the subdomain and the URL, but the site states that as repository owner you keep complete control over your published content — and all rights and duties that come with publishing a website remain your responsibility. That means content problems, broken builds, and GitHub Pages misconfiguration are on your side; the subdomain record and the naming list are on theirs. Directing your question to the right side saves a round trip.

Your page also has to provide reasonable content with a clear connection to JavaScript. If a request is declined or questioned on those grounds, the fix is to adjust the content, not the DNS.

How do I get a free JS.ORG subdomain for my GitHub Pages site?

JS.ORG offers free subdomains such as https://foo.js.org to JavaScript developers who host a project on GitHub Pages, provided the page has reasonable content with a clear connection to JavaScript. The process has four steps: set up your GitHub Page, choose a subdomain based on your existing GitHub Pages URL, add a CNAME file to your repo, and open a pull request against the JS.ORG repository. Your new URL should go live within 24 hours.

Before you start

You need:

  • A GitHub account.
  • A GitHub Pages site that already has some reasonable content.
  • A clear JavaScript connection on that page — this is the stated requirement for approval.

You keep complete control over your published content as the repository owner, but all rights and duties that come with publishing a website remain your responsibility.

Step 1: Set up your GitHub Page

If you haven't already, log in to GitHub and set up your GitHub Page following GitHub's instructions. Make sure you add some reasonable content to the new page before continuing — an empty or unrelated page is unlikely to pass review.

Step 2: Choose your js.org subdomain

Your subdomain must be derived from your existing GitHub Pages URL. For a page at http://foo.github.io/bar, either of these is possible:

  • foo.js.org (your username)
  • bar.js.org (your repo name)

More details are available in the JS.ORG wiki.

Step 3: Add a CNAME file

Add a file named CNAME to your repo. For project pages, place it in the gh-pages branch. The file should contain a single line matching the domain you chose, for example:

foo.js.org

No quotes. If you run into problems, check the "Custom URLs" section of the GitHub Pages Help.

Step 4: Open a pull request

Make a pull request in the JS.ORG GitHub repository that adds your subdomain to the list of existing JS.ORG domains. Your new URL should go live within 24 hours.

Keep an eye on your pull request in case of a naming conflict or a question from the JS.ORG side.

Quick reference

Step Action Where
1 Create and populate a GitHub Page Your GitHub account
2 Pick username- or repo-based subdomain From your GitHub Pages URL
3 Add CNAME with the chosen domain Your repo (gh-pages branch for project pages)
4 Submit a pull request adding your subdomain JS.ORG GitHub repository

Common snags

  • Naming conflict — someone may already have claimed the subdomain you want; watch your pull request for feedback.
  • Content review — the page must have a clear connection to JavaScript; unrelated content can hold up or block approval.
  • Wrong CNAME location — for project pages the file belongs in the gh-pages branch, not the default branch.
  • Timing — allow up to 24 hours after your pull request is merged for the URL to go live.
What content is required to qualify for a JS.ORG subdomain?

JS.ORG grants free subdomains to GitHub Pages sites that contain "reasonable content with a clear connection to JavaScript." That is the core requirement stated on the site. A page that is empty, a placeholder, or unrelated to JavaScript does not meet it. If your page qualifies, you keep full control over the published content — and full responsibility for it.

The content rule, in practice

JS.ORG describes the requirement in one sentence: your page "has to provide some reasonable content with a clear connection to JavaScript." There is no published checklist of accepted topics, so the practical test is whether a visitor landing on your subdomain would immediately see a JavaScript-related project, tool, library, demo, documentation, or article.

Examples that clearly fit the stated requirement:

  • Documentation or a landing page for a JavaScript library, framework, or CLI tool
  • A JavaScript-focused blog, tutorial collection, or demo site
  • A project page for a JavaScript app, game, or experiment
  • A personal developer site whose content is centered on JavaScript work

Examples that likely fail:

  • A default GitHub Pages template with no edits
  • A site about an unrelated topic that happens to be built with JavaScript
  • An empty repository or a page with only a "coming soon" message
  • A parked domain or link-collection page with no JavaScript substance

The distinction is about the subject of the content, not the technology used to build it. A cooking blog written in React is still a cooking blog.

What you keep and what you owe

JS.ORG states that as the repository owner you "keep complete control over your published content." The same paragraph adds that "all rights and duties that come along with publishing a website remain in your responsibility." In plain terms: JS.ORG does not review or take ownership of what you publish, but you are the one accountable for it. The site points to its Terms and Conditions for the details, so read those before submitting if your content involves anything sensitive.

How the content requirement fits the application steps

The content requirement is checked against the GitHub Page you already have, so it comes before the subdomain request:

  1. Set up your GitHub Page and add reasonable, JavaScript-related content to it.
  2. Choose your subdomain based on your existing GitHub Pages URL — for http://foo.github.io/bar, either foo.js.org or bar.js.org is possible.
  3. Add a file named CNAME to your repo (in the gh-pages branch for project pages) containing a single line with the chosen domain, e.g. foo.js.org without quotes.
  4. Open a pull request in the JS.ORG GitHub repository adding your subdomain to the list of existing domains.

The new URL should go live within 24 hours. JS.ORG advises watching your pull request in case of a naming conflict or a question from their side — which is also where a content problem would surface.

Common reasons a request stalls

  • Thin content. The page exists but says nothing meaningful yet. Add real content before submitting.
  • Weak JavaScript connection. The link to JavaScript is not obvious from the page itself. Make it explicit in the title, description, or first screen.
  • Naming conflict. Someone else already requested the same subdomain; the pull request is where this gets resolved.
  • CNAME mistakes. Wrong branch, wrong filename, or extra characters on the domain line will break the custom URL setup.

If you are unsure whether your project qualifies, the safest move is to make the JavaScript connection unmistakable on the page first, then submit. The requirement is about what a visitor sees, not what you intend to build later.

Website Overview

An established domain and managed infrastructure suggest continuity of operations and may support dependable delivery, although neither guarantees service quality. Page metadata, canonical configuration and social previews work together to provide more consistent search and sharing presentation.

Domain and Registration

Registered in 1996, this domain has about 30 years of history. That suggests continuity, although ownership and purpose may have changed. Transfer-protection status is present, helping reduce the risk of unauthorized domain transfers. The registrar is NameCheap, Inc., a widely used domain service provider. The domain uses the common .org extension, which is not an independent safety signal.

DNS and Email

Nameservers are provided by Cloudflare, indicating managed DNS hosting. MX records point to the improvmx.com email service. DNSSEC is enabled, allowing validating resolvers to authenticate signed DNS data. No CNAME was found; the observed records resolve directly to addresses. SPF and DMARC are configured. DKIM status is unknown.

TLS and Certificates

The public key uses EC with 256 bits. The server supplied a complete certificate chain. No organization name is present in the certificate; the available fields are consistent with domain validation. The certificate was issued within the Google Trust Services cloud or CDN ecosystem. The certificate's total validity is about 90 days, consistent with a short renewal cycle.

HTTP and Browser Security

The checked browser-security headers were not detected, leaving fewer explicit browser-side safeguards. CORS permits any origin to read this response. This is common for public resources; sensitive responses need narrower handling. No X-Powered-By header was found, reducing one common source of backend fingerprinting information. The cf-ray response header indicates a CDN or caching proxy in the delivery path. No obvious internal addresses or debug information were found in the headers.

Technology Stack Analysis

The public page identifies Cloudflare without precise versions, leaving fewer clues for version-specific scanning.

Search and Social Sharing

Twitter Card metadata is configured. The title has 36 characters, within a common display range. A meta description is present, with 60 characters. The observed directives allow indexing and link following. No Generator meta tag is publicly exposed.

Hosting and Email

DNSCloudflare
HostingCloudflare
Emailimprovmx.com
Location Location unknown 104.26.8.84

User reviews (0)

  • No reviews yet.

Pages, Search and Sharing

Meta descriptionDedicated to JavaScript and its awesome community since 2015
Canonical URLhttps://js.org/index.html
LanguageEnglish (default)
Twitter Cardsummary

Social Sharing Preview

12 fields

robots.txt (opens in a new tab)

HTTP 404

No robots.txt found

Sitemaps

1

Registration details RDAP / WHOIS

RegistrarNameCheap, Inc.
Registered1996-06-26
Expires2032-06-25
Domain statusclient transfer prohibited
Nameserversmiles.ns.cloudflare.com、pam.ns.cloudflare.com
DNSSECsigned

DNS records

TypeNameValueTTLPriority
Ajs.org104.26.8.84300—
Ajs.org104.26.9.84300—
Ajs.org172.67.73.64300—
AAAAjs.org2606:4700:20::681a:854300—
AAAAjs.org2606:4700:20::681a:954300—
AAAAjs.org2606:4700:20::ac43:4940300—
MXjs.orgmx1.improvmx.com30010
MXjs.orgmx2.improvmx.com30020
NSjs.orgmiles.ns.cloudflare.com86400—
NSjs.orgpam.ns.cloudflare.com86400—
TXTjs.orggithub-verification=Co5XEGjgZ54phI90tdeEbcXBt0LErl0nKNUpqPmR300—
TXTjs.orgv=spf1 -all300—
DSjs.org2371 13 2 bb5749b06b705cabaa999f6adc60b60e528c502078e1a1075206a852956d86703600—
DMARC_dmarc.js.orgv=DMARC1; p=reject; pct=100; rua=mailto:[email protected]; sp=reject; aspf=s;300—

TLS and certificates

AssessmentNormal configuration
Supported protocolsTLSv1.2、TLSv1.3
Negotiated protocolTLSv1.3
Certificate subjectjs.org
IssuerGoogle Trust Services
Valid until2026-12-25T23:11 · Remaining when checked: 86 days
Verification detailsCertificate trust: Passed · Hostname match: Passed

HTTP response headers

HeaderValue
content-typetext/html; charset=utf-8
cache-controlmax-age=600
servercloudflare
access-control-allow-origin*

Identified technologies

Cloudflare