Skip to main content
Security guideReviewed

CORS misconfiguration: which sites a browser lets read your responses, and the settings that let the wrong ones in

Cross-origin resource sharing (CORS) is how your server tells a visitor's browser which other websites may read its responses.

It does not stop simple requests reaching your server, and it does not check who is asking. This guide explains the headers, the preflight and the five misconfigurations that hand the read to sites you never meant to trust, with a request trace and a regression test you can run with Node.js alone.

CORS request trace and regression test

An illustration on invented origins and a made-up account. A Node.js lab with no installs sends simple and preflighted requests from an allowed origin, a disallowed origin and with credentials under seven CORS policies, and prints each request's headers, each response's headers, the server's log line and two verdicts: what the scripted client received, and whether a browser would let the page read it, decided from the real headers by the Fetch Standard's rules.

How to use it

A regression test asserts headers and visibility, passing only on the exact allow-list, and steps show the same in your own browser. For learning and for testing a policy you own.

cors-misconfiguration.txt

Introduction26 lines

ILLUSTRATION ONLY. The API, its account and every origin below (app.example.com, api.example.com, staging-app.example.com, attacker.example.net and app.example.com.attacker.example.net) are invented for this page. The lab runs on your own machine, binds to 127.0.0.1, keeps everything in memory and serves made-up data. Use it for learning and for testing a CORS policy you own. What this asset is, and what it is not. Part 1 is a Node.js lab: an API with seven switchable CORS policies, a scripted client and a regression test. For every exchange, the trace in Part 2 prints the request headers that matter, the response headers, the server's own log line and two verdicts side by side: what the scripted client received, which is always whatever the server sent, and whether a browser would let the calling page read it. The second verdict comes from browser-rules.mjs, which applies the WHATWG Fetch Standard's CORS check and preflight rules to the real response headers. It is not a browser: it leaves out the preflight cache, redirects, the length limits on safelisted header values, the Range header and the cookie rules. Part 4 shows you how to check it against your own browser. The cookie assumption. With credentials, the scripted client always sends the session cookie. A real browser sends it to another site only when the cookie's SameSite attribute and the browser's third-party cookie settings allow it (MDN Set-Cookie; MDN CORS guide). The trace shows the case where they do. Written and run on: Node.js 26.0.0, the only version it was run on. It uses node:http, node:crypto, node:test and node:assert, which ship with Node.js, so there is nothing to install. Every output below comes from that run; timings and ports will differ on your machine. What browser-rules.mjs follows: the WHATWG Fetch Standard (Living Standard, last updated 19 October 2026), the sections "CORS check", "CORS-preflight fetch" and "HTTP fetch", and the definitions of "CORS-safelisted method", "CORS-safelisted request-header", "CORS-unsafe request-header names" and "CORS non-wildcard request-header name". The seven policies: none no CORS headers at all allow-list the whole origin must be on a written list (https://app.example.com); credentials allowed; Vary: Origin wildcard Access-Control-Allow-Origin: * wildcard-credentials * with Access-Control-Allow-Credentials: true reflect-credentials copies any Origin into Access-Control-Allow-Origin with credentials, and echoes the requested headers on a preflight prefix-match accepts any origin that starts with https://app.example.com null-allowed the allow-list, plus null The five requests sent under each policy: 1 GET /api/account from the app's own origin, with credentials 2 GET /api/account from the disallowed origin, with credentials 3 GET /internal/report, a route with no sign-in that trusts its network, from the disallowed origin, without credentials 4 POST /api/notes with a JSON body from the app's own origin, with credentials (a Content-Type of application/json needs a preflight) 5 the same POST from the disallowed origin The disallowed origin is https://attacker.example.net, except under prefix-match (https://app.example.com.attacker.example.net) and null-allowed (null), where the trace uses the origin that gets through.

What CORS is, and what a misconfiguration gives away

Picture a customer portal at app.example.com whose pages fetch account details from an API at api.example.com.

To the browser those are two different origins, so by default a page on one cannot read what the other sends back. Cross-origin resource sharing, shortened to CORS, is how the API says which other origins may read its responses.

A CORS misconfiguration is a policy that says yes to origins it should not, so that a page on someone else's site can read what your API returns to a signed-in visitor.

One point matters more than any header. CORS relaxes a browser restriction on reading responses. It does not stop a simple request from reaching your server, it does not authenticate anyone, and a client that is not a browser ignores it. MDN's CORS guide says the headers let servers describe which origins are permitted to read that information from a web browser.

OWASP's test for CORS, WSTG-CLNT-07, says it is up to the client to determine and enforce whether it has access to the response data, and that relying on the Origin header for access control checks is not a good idea because it may be spoofed outside the browser.

The README of the Express cors middleware puts it plainly under Common Misconceptions: CORS is not access control, and any HTTP client, including another server, can call your API regardless of CORS settings.

So a permissive policy is dangerous because of what a logged-in visitor's browser can then be made to read. When the other site's page asks for credentials, the browser can attach the visitor's cookie, where the cookie's SameSite attribute and the browser's third-party cookie settings allow it, and if your policy approves that site, it hands the page's script the response.

A strict policy, in turn, is not a substitute for checking who is asking. OWASP's HTML5 Security Cheat Sheet says not to rely only on the Origin header for access control checks and to protect sensitive data with application-level protocols.

The OWASP Top 10:2025 says access control is only effective when implemented in trusted server-side code or serverless APIs, and lists CORS misconfiguration that allows API access from unauthorised or untrusted origins among the common access control vulnerabilities in A01 Broken Access Control.

The hono advisory described below maps a CORS flaw to MITRE's CWE-942, Permissive Cross-domain Security Policy with Untrusted Domains, which describes a web-client protection mechanism whose policy includes untrusted domains the web client is allowed to communicate with. CWE-942 does not name CORS; its examples are Flash and Silverlight policy files. The OWASP Top 10:2025 maps CWE-942 to A02 Security Misconfiguration.

Origins and the same-origin policy in plain terms

An origin is the scheme, hostname and port of a URL, and two URLs share an origin only when all three match.

MDN's glossary gives http://example.com and http://example.com:8080 as different origins because the ports differ, and http://example.com and http://myapp.example.com as different because the hostnames differ. So https://app.example.com and https://api.example.com are two origins, even when one business runs both.

The same-origin policy is the browser's default between origins. MDN places the interactions it controls in three categories, and two matter here: cross-origin writes, such as links, redirects and form submissions, are typically allowed, and cross-origin reads are typically disallowed, though MDN notes that read access is often leaked by embedding.

A page on another site can make a visitor's browser send a request to your API. What the policy stops, by default, is that page's script reading the answer.

MDN's CORS guide says fetch() and XMLHttpRequest follow the same-origin policy, so a web application using them can only request resources from its own origin unless the response from the other origin includes the right CORS headers.

CORS is the opt-in. The WHATWG Fetch Standard, which MDN notes now defines CORS, says the protocol exists to allow sharing responses cross-origin and to allow more versatile fetches than an HTML form can make. It says the protocol has to be an opt-in mechanism to prevent leaking data from responses behind a firewall, and, for requests that include credentials, to prevent leaking potentially sensitive data. Every misconfiguration on this page is that opt-in given to more origins than the owner meant.

CORS headers: how the server says yes

A browser adds an Origin header to a cross-origin request made by a page's script, naming the page's origin.

The server answers with headers, and the browser decides. In the Fetch Standard, Access-Control-Allow-Origin indicates whether the response can be shared, by returning the literal value of the Origin request header, which can be null, or *. Its syntax allows one value: one origin, null or the wildcard.

MDN's reference says a server that supports clients from several origins must return the origin of the specific client making the request, which takes code that checks the Origin header against a list of allowed origins and, when it is on the list, sends that same value back.

The browser's side is a short algorithm the Fetch Standard calls the CORS check. With no Access-Control-Allow-Origin, it fails. For a request without credentials, * passes. Otherwise the value has to equal the request's origin exactly, and for a request with credentials, Access-Control-Allow-Credentials also has to be true.

When the check fails, the fetch returns a network error to the page. MDN adds that, for security reasons, the script is not told the specifics of a CORS failure; the browser's console shows them.

MDN's reference for Access-Control-Allow-Credentials says credentials include cookies, TLS client certificates and authentication headers containing a username and password. Browsers do not send them on cross-origin fetch() or XMLHttpRequest calls by default; a page has to ask, with the fetch() credentials option set to include, which otherwise defaults to same-origin.

A simple GET with credentials goes out without a preflight, carrying the cookie, and the browser then refuses to make the response available to the page unless Access-Control-Allow-Credentials is true.

That header has one valid value, true, and it is case-sensitive. MDN's advice when you do not need credentials is to omit it rather than set it to false.

The wildcard and credentials do not mix, and the Fetch Standard is exact about which side refuses. Its table of combinations says that if the credentials mode is include, Access-Control-Allow-Origin cannot be *, and marks the response as not shared even when Access-Control-Allow-Credentials is true.

The refusal is the browser's: in the CORS check, * never equals the request's origin, so a credentialed request fails the check and the page receives a network error in place of the response, which the server has already sent.

MDN describes the same outcome: the browser blocks access to the response and reports a CORS error in the developer tools console. The rule extends to Access-Control-Allow-Headers, Access-Control-Allow-Methods and Access-Control-Expose-Headers, where * counts as a wildcard only for requests without credentials.

When the value of Access-Control-Allow-Origin depends on the request's Origin, tell caches. MDN's reference says a response that names an explicit origin should also include Vary: Origin, and the Fetch Standard says Vary is to be used whenever the CORS requirements are more complicated than * or one fixed origin.

Its example is a response cached from a plain navigation, without Access-Control-Allow-Origin, being reused for a later CORS request. For * or one fixed origin, it says to send Access-Control-Allow-Origin on every response for that resource and not to use Vary.

CORS is not the only gate on cookies. MDN's CORS guide says third-party cookie policies still apply to credentialed requests to a different domain, and may prevent the cookie being sent even when the server allows credentials.

The IETF cookie draft says most user agents limit third-party cookies in a variety of ways, so resources cannot rely on them being treated consistently. The SameSite attribute also decides: MDN's Set-Cookie reference says Lax leaves the cookie off cross-site requests made with fetch(), while None sends it with cross-site requests.

The cookie security guide covers those attributes; this page assumes the cookie is sent, which is the case CORS has to handle.

The CORS preflight: what it asks, and what it is not

Some cross-origin requests go out at once and some wait for permission.

MDN calls the first kind simple requests, a term from the obsolete CORS specification that the Fetch Standard does not use. In the Fetch Standard's terms, the method has to be a CORS-safelisted method, GET, HEAD or POST, and every header the page sets has to be a CORS-safelisted request-header: Accept, Accept-Language, Content-Language, Content-Type or Range, each with conditions on its value.

For a header the page sets, Content-Type qualifies only as application/x-www-form-urlencoded, multipart/form-data or text/plain. MDN adds that no event listener may be registered on an XMLHttpRequest upload and no ReadableStream may be used.

MDN explains why simple requests skip the preflight: an HTML form could already send them to any origin, so the server does not have to opt in to receive a request that looks like a form submission, although it still has to opt in with Access-Control-Allow-Origin before the response is shared with script.

Anything else gets a preflight first, unless the browser holds a cached approval. A Content-Type of application/json, a PUT or DELETE, or a header such as Authorization or X-Requested-With all fall outside the safelist.

The preflight is an OPTIONS request to the same URL. Under the Fetch Standard, the browser sends Access-Control-Request-Method with the method it wants to use and, when there are any, Access-Control-Request-Headers with the names of the headers that are not safelisted, in lower case. It never includes credentials.

The answer has to pass the same CORS check, using the credentials mode of the request that will follow, and have an ok status such as 200 or 204. Access-Control-Allow-Methods has to cover the method unless it is safelisted, and Access-Control-Allow-Headers has to cover each header that is not safelisted; for a credentialed request * does not count, and Authorization always has to be listed by name.

Only then does the browser send the actual request. When the preflight fails, the fetch ends in a network error and the actual request is not sent.

Access-Control-Max-Age says how many seconds the browser may cache that approval. The Fetch Standard's default is 5 seconds and lets a browser impose its own limit; MDN's reference lists 24 hours in Firefox and 2 hours in Chromium from version 76.

A cached approval can be reused until its max-age runs out, so a narrowed list of methods or headers can take that long to reach a browser that cached the old answer.

A preflight is not a security check run on your behalf. The Fetch Standard describes it as a check to see if the CORS protocol is understood. It runs only in browsers and only for requests that are not simple, and it carries no credentials, so it says nothing about who the user is.

ASVS 5.0 notes that the preflight can also be a useful request forgery prevention mechanism for endpoints that are not designed to be called from another origin, and its requirement 3.5.2, at Level 1, asks that an application relying on it makes sure the functionality cannot be called with a request that does not trigger a preflight, which may require checking the Origin and Content-Type request headers or using an extra header field that is not CORS-safelisted.

OWASP's HTML5 cheat sheet makes the related point that current implementations might not perform a preflight, so it is important that ordinary GET and POST requests perform any access control necessary.

CORS misconfigurations, in the order a reviewer meets them

Each of these is a policy that says yes to an origin its owner did not mean to trust.

The request trace on this page runs every one of them against the same invented API, so the effect described here is also shown there, request by request.

Reflecting any origin

The quickest way to make a cross-origin error go away is to copy the request's Origin header into Access-Control-Allow-Origin and add Access-Control-Allow-Credentials: true. 1 min read

Trusting the null origin

Origin: null looks like no origin at all, and it can be tempting to list it so that a page opened from a local file works. 1 min read

Loose matching

An allow-list is only as good as its comparison. 1 min read

A wildcard on an API that trusts its network

Access-Control-Allow-Origin: * is the honest setting for public data, and the Fetch Standard treats it that way. 1 min read

Allowing credentials too widely

Access-Control-Allow-Credentials: true is the setting that turns a read into a read of the visitor's account. 1 min read

What a strict CORS policy still leaves to your server

The exact allow-list in the trace does everything CORS can do, and its own output shows where that stops.

In exchange 2, a page on another site asks for the signed-in account with credentials. The server's log line shows the request arrived with a valid session and the account data was sent; the browser rule then withholds it from the page.

Nothing in CORS stopped the server doing the work, and the Fetch Standard warns that any work the server performs might nonetheless leak through side channels, such as timing.

In exchange 5, the other site's preflight fails, so a browser would not send the JSON POST. The scripted client sends it anyway, with the same session cookie, and the note is saved. A browser honours the preflight; nothing else has to. The regression test's last check passes under every policy for the same reason: with no Origin header and no preflight, only the session check decides.

So CORS sits on top of the checks your server makes, never in their place. Authenticate every request, decide on the server what this user may read and change, and keep CSRF defences on state-changing routes. OWASP's HTML5 cheat sheet says CORS does not prevent the requested data from going to an unauthorised location, and that the server still needs its usual CSRF prevention.

How to write a CORS policy down

Write the policy as data that a person can read and a test can check, rather than as logic buried in middleware.

Part 6 of the asset is a record to fill in for each route or group of routes. These are the rules it encodes.

  • One list of origins per environment. Production lists the production front ends and staging lists staging; localhost and preview addresses belong in development configuration only. Compare the incoming Origin with the list exactly and send that same value back, as MDN's reference describes.
  • Per route where needed. OWASP's HTML5 cheat sheet says to use Access-Control-Allow-Origin only on the URLs that need cross-domain access, not for the whole domain. Public data that needs no sign-in and no network position can take * on its own routes, under the conditions the Fetch Standard sets out.
  • Credentials only where the route needs the visitor's cookie, and never with *, which the browser refuses with credentials (Fetch Standard).
  • Explicit methods and headers in the preflight answer. MDN says a server responding to a credentialed request must not use * in either, so the lists have to be written out anyway.
  • Vary: Origin on every response from a route whose Access-Control-Allow-Origin depends on the request (MDN; Fetch Standard).
  • An Access-Control-Max-Age you are prepared to wait out after a change, within the limits browsers impose (Fetch Standard; MDN).
  • No null and no pattern matching: the whole origin, or nothing (MDN; OWASP).
  • A regression test that asserts what a page on each origin could read, not only which headers came back. ASVS 5.0 requirement 3.4.2 states the outcome the test should hold you to.

What frameworks and CORS libraries do by default

Read your library's defaults before you trust a configuration that works.

The Express cors README's default configuration sets origin to * and the methods to GET, HEAD, PUT, PATCH, POST and DELETE. Setting origin to true reflects the request origin, a string sets one origin, a regular expression reflects any origin that matches it, an array accepts the strings and patterns it lists, and a function can apply logic of your own. credentials: true adds Access-Control-Allow-Credentials. Its examples show the middleware sending Vary: Origin when it names an origin.

Next.js documents three places to set CORS headers. Its Route Handler reference shows them set on one handler's response with the standard Web API methods, in an example that sends Access-Control-Allow-Origin: *, and says that to add CORS headers to multiple Route Handlers you can use Proxy or the next.config.js file.

Its Proxy reference shows an allowedOrigins array: the example checks the request's Origin against it with includes, sends Access-Control-Allow-Origin with that origin only when it is on the list, and answers OPTIONS preflights directly.

For a route that reads cookies, copy the list-and-compare shape rather than the wildcard, add Access-Control-Allow-Credentials: true if the front end sends cookies, and add Vary: Origin, which that example leaves out and the Fetch Standard asks for when the value depends on the request.

The Next.js guide in this library includes the route handler check that handlers returning private data send CORS headers only to origins you expect.

If you use hono, the advisory above applies to versions before 4.12.25. Whatever the framework, the test in Part 3 of the asset checks the behaviour rather than the configuration, which is what matters when a default changes under you.

Running the request trace on your own machine

The trace is an illustration, written for this page.

An invented API at https://api.example.com, served on 127.0.0.1 on a port the system picks, has one made-up account, an office-only route that needs no sign-in, and a JSON route that saves a note. Its CORS policy switches between the seven in the asset.

It was written and run on Node.js 26.0.0 with modules that ship with Node.js, so there is nothing to install, and every output in the asset is copied from that run. Use it for learning and for testing a policy you own.

It cannot run a browser, and it does not pretend to. A scripted client sends each request with the Origin header and, where credentials are included, the session cookie a browser would attach, and prints what the server sent back.

Beside that, a small function in browser-rules.mjs applies the Fetch Standard's CORS check and preflight rules to the real response headers and says whether a browser would let the calling page read the response, or send the actual request at all.

That function is the published rules applied to real headers. It is not a browser, and it leaves out the preflight cache, redirects and the cookie rules that decide whether a cookie is sent.

  • Save the five files into an empty folder and open a terminal there.
  • Run node run-trace.mjs. For each policy it prints five exchanges, each with the request headers, the response headers, the server's log line, what the client received and what a browser would allow, then a summary table.
  • Run node cors-policy.test.mjs. All nine tests pass on the allow-list. Run it again with a policy name, such as reflect-credentials or null-allowed, and the tests that policy breaks fail. The Node.js test runner sets the exit code to 1 when any test fails, so a pipeline step running it fails too.
  • Run node browser-check.mjs allow-list and follow Part 4 to watch your own browser do what the trace predicts.

Seeing it in your browser's network panel

The browser check starts the API and two plain pages on 127.0.0.1, each on its own port, so each is a different origin. The API lists the first page's origin and not the second. Sign in at the address it prints, open each page, and run the two fetch lines it prints from the developer tools console: one credentialed GET of the account and one JSON POST that needs a preflight.

In the Network panel, select each request and read the Origin request header and the Access-Control-Allow-Origin, Access-Control-Allow-Credentials and Vary response headers. The terminal prints one line for every request the API receives. From the unlisted page you should see the GET arrive with a valid session and the account sent, while the console reports the fetch failed; and for the POST, only the OPTIONS line, because the browser holds the POST back when the preflight fails. Restart with reflect-credentials and the unlisted page can read the account.

Pointing the regression test at your own API

Keep the nine tests and change three things: start your own API on a test port with a seeded test account in place of the lab, use your own routes in place of the three lab routes, and set the allowed origin to each origin on your environment's list.

Keep the attacker, look-alike and null origins, and keep both kinds of assertion for every route: the headers, and what corsCheck and checkPreflight say a page could read or send. Run it against a staging or local copy with test accounts.

How to test a CORS policy you own

OWASP's WSTG-CLNT-07, Testing Cross Origin Resource Sharing, has two objectives: identify endpoints that implement CORS, and ensure that the CORS configuration is secure or harmless.

These steps cover both on an application you own.

  • Find every route that sends Access-Control-Allow-Origin. Search the code and configuration for the header and for your CORS library's settings, and read the response headers of each API route, including routes that serve files and errors.
  • Send each route a request with Origin set to your front end, to an origin not on your list, to a look-alike that starts or ends with your domain, and to null, each with and without a test account's session cookie. Record Access-Control-Allow-Origin, Access-Control-Allow-Credentials and Vary.
  • Send an OPTIONS preflight for each method and header your front end uses that is not safelisted, from your front end and from an unlisted origin, and record Access-Control-Allow-Methods, Access-Control-Allow-Headers and Access-Control-Max-Age.
  • Decide what a page could read with the CORS check, not by eye. browser-rules.mjs in the asset does this from recorded headers.
  • For every route that sends *, confirm the response includes no sensitive information (ASVS 5.0 requirement 3.4.2) and nothing protected through IP authentication or a firewall, which the Fetch Standard says makes using the CORS protocol unsafe.
  • Test only systems you own or are authorised in writing to test, with test accounts and test records.

Where CORS ends and the neighbouring guides begin

A forged request does not need to read anything, and a simple request needs no preflight, so CORS does little against cross-site request forgery; the CSRF guide covers the checks that refuse a forged request.

Whether a session cookie travels on a cross-site request at all depends on its attributes, which the cookie security guide covers. A token your own script puts in an Authorization header is not something the browser attaches by itself, and how an API should verify such tokens is the subject of the JWT security guide.

Checking that every API call comes from someone allowed to make it, the work CORS never does, belongs to the API security guide. And the Next.js guide covers where CORS headers sit among the other entry points of a Next.js application.

Where an outside test fits

Your own trace checks the routes you know about.

A Clever Ops web application and API penetration test covers authentication and sessions, what each role can see and change, and the API called directly rather than only through the screens. The website security check, which does not sign in, includes cross-origin rules under WSTG-CLNT-07: its good result is that endpoints either send no Access-Control-Allow-Origin header or name the origins allowed, and none echoes back whatever origin asks.

Each finding comes with evidence, a fix written for your stack and the criteria the retest will use. If Clever Ops built or hosts your application, the work is a security review rather than an independent test, and the report says who built it and who hosts it.

Frequently asked questions

A cross-origin resource sharing policy that lets origins read your responses when they should not: echoing back any Origin, listing null, matching origins loosely, sending * on data that relies on network position, or allowing credentials more widely than the routes need. With credentials allowed, a page on another site can read what your API returns to a signed-in visitor's browser. The hono advisory on this page maps such a flaw to MITRE's CWE-942, Permissive Cross-domain Security Policy with Untrusted Domains.

No. CORS tells browsers which other origins may read your responses. It does not stop a simple request reaching your server, it does not authenticate anyone, and clients that are not browsers ignore it. WSTG-CLNT-07 says the Origin header may be spoofed outside the browser and that application-level protocols are still needed to protect sensitive data. Authentication and authorisation on your server decide who may do what.

For public data anyone could fetch, the Fetch Standard calls it safe, and the browser does not share a credentialed response under it. It is unsafe for anything protected by IP address or a firewall, and ASVS 5.0 requirement 3.4.2 asks that a response sent with * includes no sensitive information.

Because the browser refuses. In the Fetch Standard's CORS check, a credentialed request needs Access-Control-Allow-Origin to equal its own origin exactly and Access-Control-Allow-Credentials to be true, so * fails and the page gets a network error, although the server has sent the response. Name the origin from an allow-list instead; reflecting whatever Origin arrives opens the account to every site.

An OPTIONS request a browser sends before a cross-origin request that is not simple, such as a POST with Content-Type: application/json or a request with an Authorization header. It carries Access-Control-Request-Method and, where needed, Access-Control-Request-Headers, never credentials, and the browser sends the actual request only if the answer approves the origin, method and headers. It is not authentication, and clients that are not browsers skip it.

Because anyone can send it. MDN says sandboxed documents and resources with schemes such as data: or file: have the origin null, that many browsers grant such documents access when Access-Control-Allow-Origin is null, and that any origin can create a hostile document with a null origin.

When Access-Control-Allow-Origin depends on the request's Origin, yes: MDN and the Fetch Standard both say to send Vary: Origin. MDN says it indicates that server responses can differ based on the Origin request header, and the Fetch Standard's example is a cached response to a non-CORS request, without Access-Control-Allow-Origin, being reused for a later CORS request. For * or one fixed origin, the Fetch Standard says to send the header on every response and not to use Vary.

Scope the right test for your application

Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.