Strip surrounding quotes
Paste "hello world" and get hello world back: one matching pair of outer quotes is peeled off, whether straight, curly, guillemets or backticks. Mismatched or missing quotes leave the text as it was. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- "hello world"
- Text
- hello world
- Original
- "hello world"
- Length
- 11
- Quote style
- double
If the first and last characters are not a known matching pair, the original string is returned unchanged with stripped set to false, so you never lose data to a guess. The engine is pure and deterministic: no network, no model, no clock, and no random sampling.
Why pasted values arrive wrapped in quotes
Quotation marks are often part of how a value was stored rather than part of the value itself. A cell copied out of a CSV export, a line pulled from a log, or a setting shown on a configuration screen frequently keeps the quotes that marked its edges in the source. Left in place, those characters make two identical names look different, store literal quote marks in a database and confuse the next import. Removing the outer pair gives back the value that was meant, such as hello world from "hello world".
Only one matching pair, never a guess
The tool looks at the first and last characters only. If they form a known pair, straight double or single quotes, curly quotes, guillemets or backticks, that pair is removed once and the inside is left exactly as it was. A value that opens with a double quote and closes with a single one is not a pair, so it comes back unchanged, and so does a word with no quotes at all. Nothing inside the text is rewritten, which keeps names and codes intact.
Where unquoting outer delimiters earns its keep
Data teams paste CSV exports into staging sheets and discover every product name still wrapped in double quotes that Excel or a dump tool left behind. Configuration editors and secret managers often display values in quoted form for readability; operators need a one-click peel before storing the value in an environment variable or a typed field that would otherwise keep the quote characters. Classroom labs that teach string hygiene can show matching pairs versus mismatched wrappers with a deterministic oracle instead of opaque spreadsheet macros that differ by locale.
Pair this tool with trim, case conversion, or CSV field quoting when you are building a small lab of deterministic text helpers for forms, CMS prep, and import pipelines. Keep requests small, pin expected outputs in tests, and you get reproducible unquoting for homework, LMS plugins, and edge workers without standing up a full parsing stack of your own.
What you can do with it
CSV and spreadsheet paste cleanup
Peel outer quotes from cells copied out of CSV dumps or Excel so product names and codes land in databases without literal quote characters.
FAQ
Which quote styles are supported?
ASCII double and single quotes, matching backticks, curly double and curly single quotes, double guillemets, and single guillemets.
What if the quotes do not match?
The string is left unchanged and stripped is false. Mismatched wrappers (for example starting with a double quote and ending with a single quote) are never guessed away.
Does it remove quotes inside the text?
No. Only the first and last characters are checked, and only that outer pair is removed. Quotation marks in the middle of a sentence stay exactly where they are.
What if a value is wrapped in two layers of quotes?
Only the outermost pair is removed, once. The inner pair stays, so a value wrapped twice comes back still wrapped once. Run it again on the result if you need that second layer gone too.
How can I tell whether anything was removed?
The result says whether quotes were stripped and which style they were, such as double quotes. When nothing matched, you get your text back unchanged, so a value without outer quotes is never altered by a guess.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/str/strip-surrounding-quotes \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"\"hello world\""}'const res = await fetch("https://api.kit.forhosting.com/str/strip-surrounding-quotes", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "\"hello world\""
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/strip-surrounding-quotes",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "\"hello world\""
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/strip-surrounding-quotes", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"\\"hello world\\""}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"\"hello world\""}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/strip-surrounding-quotes", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "\"hello world\""
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.strip_surrounding_quotes",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_chars | 100000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
When you paste a cell from a spreadsheet, a string from a JSON log, or a value from a configuration file, the text often still carries the outer quotation marks that delimit it in the source. Those wrappers break equality checks, seed databases with literal quote characters, and confuse import pipelines that already treat the field as a string. This strip surrounding quotes tool removes a single matching pair of quotes wrapping your text—ASCII double or single quotes, curly typographic quotes, guillemets, or backticks—and returns the clean inner value. Use it free in the browser for cleanup and data prep, or call the API at $0.002 per successful request when CI, ETL jobs, and form handlers need the same reproducible unquote step.
What surrounding quotes mean and what this tool removes
Matching pairs include ordinary ASCII double quotes and single quotes, matching backticks, left and right curly double quotes, left and right curly single quotes, double guillemets, and single guillemets. The tool does not walk the interior of the string rewriting escapes, doubling rules from RFC 4180, or nested layers—only the outer pair is peeled. A value that starts with a double quote and ends with a single quote is left unchanged, because those characters are not a matching pair. A bare word with no outer quotes is likewise unchanged, with stripped false so callers can branch without inventing a second success code. After a successful strip of two quote characters around empty content, the result may legitimately be the empty string; that is different from rejecting a missing field. Surrounding quotes are the outer delimiters that mark a string value in CSV fields, JSON tokens, shell-style configuration, and many export formats. People copy those values into forms, spreadsheets, and scripts and accidentally keep the opening and closing quote characters as part of the payload. This capacity answers that narrow problem: look at the first and last characters of the input; if they form a known matching quote pair, remove that pair once and return the interior text. Empty input is rejected with invalid_input rather than returning an empty success, because a blank field usually means the form was not filled. Response fields are stable: text is the cleaned or original string, original echoes the exact input, stripped is a boolean, quote_style names the pair when a strip happened, length is the character count of text, and method is the fixed tag strip_surrounding_quotes for logs and multi-tool pipelines.
Input contract, validation, and reproducible results
The value must be a non-empty string; finite numbers and bigints are stringified to decimal text first so a bare product code typed as a number still processes after conversion. POST a JSON body with a required text field holding the string that may still wear outer quotes. Aliases input, string, value, content, and s are accepted so query strings, spreadsheet columns, and typed clients can reuse the contract without renaming keys. Booleans, plain objects, and arrays are rejected with a clear invalid_input message so a mistaken JSON body does not become the word true or an unhelpful object dump. Length is capped at one hundred thousand characters so a runaway paste cannot monopolize a Worker; longer payloads fail with an explicit limit message rather than a silent truncation. When the outer pair matches, text is original without the first and last characters, stripped is true, and quote_style is one of double, single, backtick, curly_double, curly_single, guillemet, or single_guillemet. When no pair matches, text equals original, stripped is false, and quote_style is omitted so optional fields stay absent rather than null. Failed validation is not billed; only successful item-unit work consumes prepaid balance at the published base price.
Where unquoting outer delimiters earns its keep
Support agents clean ticket snippets that arrived as "status":"open" style fragments and extract the quoted token without writing a one-off script.
Integration use cases
JSON and config value extraction
Unquote a single string token copied from a JSON log line or configuration file before pasting into env vars, fixtures, or form fields.
Deterministic import and CI hygiene
Normalize quoted tokens in ETL steps and unit tests with a pure, byte-stable outer-pair strip that never depends on locale or the clock.
Technical questions
How do I strip surrounding quotes from a string?
Send a non-empty text field (or alias input, string, value, content, s). If the first and last characters form a known matching quote pair, the API returns the inner text with stripped true; otherwise the original string is returned unchanged.
Does this unescape CSV or JSON escapes inside the string?
No. Only the outer matching pair is removed. Interior doubled quotes, backslash escapes, and nested layers are left as-is so the result stays a simple peel, not a full format parser.
What does strip surrounding quotes cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.