That exact symptom appears in Streamlit issue #7866. A later report from the same reporter was closed as overlapping, so it should not be counted as an independent report or a separate confirmed bug. The useful lesson is to decide what the source punctuation means before converting the input.

Here is a small text-column workflow for apps that can let users paste text first and review converted values afterward. It uses Python's standard-library Decimal and native Streamlit widgets. The complete code below is free to use under the MIT license.

Keep the input and the number separately

Three decisions make this workflow predictable:

• Preserve the raw string, including leading integer zeros, alongside the result.
• Choose a specific input grammar. This first example accepts comma decimals and does not accept thousands grouping.
• Construct Decimal directly from the validated text. Return a string for the JSON preview so it does not turn into a binary floating-point number.

Display formatting is a separate concern. The NumberColumn documentation says its formatting does not change the value returned by st.data_editor. A community discussion about localized formatting also illustrates why changing a Python locale is not the same as selecting the browser's display language. Neither operation reconstructs punctuation already lost during conversion.

A converter with a deliberately small grammar

Save this as decimal_comma.py. It accepts a string or None from the text column:

import re
from decimal import Decimal

def convert(raw):
    if raw is None:
        return {"raw": raw, "status": "empty"}
    text = raw.strip(" \u00a0\u202f")
    if not text:
        return {"raw": raw, "status": "empty"}
    if len(raw) > 256 or re.fullmatch(r"[+-]?[0-9]+(?:,[0-9]+)?", text) is None:
        return {"raw": raw, "status": "invalid"}
    return {"raw": raw, "decimal": str(Decimal(text.replace(",", "."))), "status": "valid"}

The regular expression requires ASCII digits, an optional leading sign and, if a comma is present, digits on both sides. It rejects currency symbols, percentages, exponents, underscores, tabs, newlines and non-finite values such as NaN. Ordinary space, non-breaking space (U+00A0) and narrow non-breaking space (U+202F) are allowed around the whole number.

1,234 is accepted as the decimal value 1.234. If your source intended a grouped integer, this grammar is the wrong choice. An ambiguous string cannot tell you the user's intention on its own.

Nonempty input longer than 256 characters is rejected. The demo treats whitespace-only input as empty. The raw input remains in every report, including invalid and empty results.

Put a text column in front of it

Save this as app.py beside decimal_comma.py:

import streamlit as st
from decimal_comma import convert

st.title("Paste decimal commas as text")
st.caption("Comma decimals, without thousands grouping. Original values stay visible.")

edited = st.data_editor(
    {"Raw value": ["23,4", "0012,00"]},
    column_config={"Raw value": st.column_config.TextColumn("Raw value", max_chars=256)},
    num_rows="dynamic",
    key="raw_values",
)
if st.button("Convert"):
    st.json([convert(raw) for raw in edited["Raw value"]])

Use Python 3.11 or newer. Create an environment, install the version used for this example, and start the local app:

python3 -m venv .venv
. .venv/bin/activate
python -m pip install streamlit==1.63.0
python -m streamlit run app.py --server.address 127.0.0.1 --server.headless true --browser.gatherUsageStats false

On Windows, activate with .venv\Scripts\activate instead. Open the local URL printed in the terminal. Click the first cell and paste this single column, then finish editing and click Convert:

23,4
0012,00
1.234,50
9007199254740993,50

The expected results are 23.4, 12.00, an invalid row, and 9007199254740993.50. The third value uses dot grouping, which this minimal converter deliberately rejects. Add an empty row to see a separate empty result.

The JSON preview keeps decimals as strings. The numerical value of 0012,00 is represented as 12.00; its leading integer zeros survive in the accompanying raw string. For arithmetic in your application, use Decimal objects and an appropriate arithmetic context. Python's Decimal documentation explains the distinction between exact construction from text and later arithmetic, which can round according to that context.

This app sends the browser input to the Python process on your computer. It is not a browser-only converter. The example does not save the values or submit them to another service. A remote deployment would receive those values on the remote server instead.

Check the cases that are easy to miss

Save this as check.py beside the converter, then run python check.py. No Streamlit installation is required for these checks:

from decimal_comma import convert

assert convert("23,4")["decimal"] == "23.4"
assert convert("0012,00") == {"raw": "0012,00", "decimal": "12.00", "status": "valid"}
assert convert("1,234")["decimal"] == "1.234"
assert convert("1.234,50")["status"] == "invalid"
assert convert("9007199254740993,50")["decimal"] == "9007199254740993.50"
assert convert("NaN")["status"] == "invalid"
assert convert(None) == {"raw": None, "status": "empty"}
assert convert(" \u00a0")["status"] == "empty"
print("All eight decimal checks passed.")

These cases check parsing and the report representation. They do not replace a real paste test from the spreadsheet and browser your users have. I checked the native text-column workflow in Chrome with Streamlit 1.63.0, including multi-row paste, empty rows, invalid grouping and long values. A text column is an alternative application input path; this does not patch NumberColumn or recover input already changed upstream.

When your source includes thousands grouping

For an application that needs both 1.234,50 and 1,234.50, expose the decimal and grouping choices explicitly. I maintain a free parser and runnable Streamlit example with those controls.

Copy decimal_text.py and LICENSE from that directory beside your code, then use:

from decimal_text import parse_decimal_text

comma_value = parse_decimal_text("1.234,50", decimal_mark=",", group_mark=".")
dot_value = parse_decimal_text("1,234.50", decimal_mark=".", group_mark=",")
assert str(comma_value) == "1234.50"
assert str(dot_value) == "1234.50"

That helper validates groups of three digits, supports three explicit space characters, rejects malformed groups such as 12.34,5, and returns Decimal objects. It has 12 tests covering its documented grammar. The accompanying app keeps raw values visible and clears the previous conversion report when the table or selected format changes.

Choose one source format for a conversion batch. If rows mix formats, ask the user to separate them or provide per-row format information. Guessing from punctuation can produce a plausible but incorrect number.

Buy me a coffee, if this helped

If this saved you a little time, you're welcome to buy me a coffee. Please don't feel obliged — using the example, reporting an issue or sharing it is appreciated too.

• USDC on Solana: 9tY6D9mwcFaJwwzEHvw2v7nhSpdjqjNBYtuooyBN6rYy
• USDC on Base: 0x568Ab98578d682FB0B0b45619BE73EbFfbf5a6eA

Please match the asset and network exactly. Fees depend on your wallet or exchange. Thank you! — Tevinch

Here are three small regression cases for a spreadsheet paste field, followed by a plain JavaScript integration. The examples use Clipboard Table, a free MIT-licensed module I maintain. It reads a defined quoted-TSV format; it does not read spreadsheet files.

1. A newline does not always end a row

This synthetic payload has a header and one data row. The Notes cell contains two lines:

const text = 'SKU\tNotes\r\n00123\t"First line\nSecond line"\r\n';

Splitting at every newline loses the distinction between a record boundary and a line break inside a cell. A quoted-TSV parser needs to remember whether it is inside a quoted field:

• Outside a quoted field, a tab ends a cell and a record separator ends a row.
• Inside a quoted field, tabs and line breaks are part of the value.
• Two consecutive quotes inside a quoted field represent one literal quote.

This matters in real integrations: community reports describe line breaks inside copied Excel cells and multiline Google Sheets paste behavior. They illustrate failure cases, not a claim that those projects still have unresolved bugs. HTML clipboard paths can behave differently from the plain-text path used here.

To run the examples below, download the module archive, extract it, and save the code as check.mjs beside index.mjs. Run node check.mjs with Node.js 22 or newer.

import assert from 'node:assert/strict';
import { parseClipboard, toRecords } from './index.mjs';

const text = 'SKU\tNotes\r\n00123\t"First line\nSecond line"\r\n';

assert.deepEqual(toRecords(parseClipboard(text)), [
  { SKU: '00123', Notes: 'First line\nSecond line' }
]);

The identifier remains a string. If the source application has already removed its zeros or rounded a long number, a text parser cannot reconstruct the missing information.

2. Trimming can delete a column

Append these checks to the same file:

assert.deepEqual(parseClipboard('\t00123\t\r\n'), [
  ['', '00123', '']
]);

assert.deepEqual(parseClipboard('A\r\n\r\n'), [
  ['A'], ['']
]);

assert.deepEqual(parseClipboard('"He said ""hello"""\t"x\ty"'), [
  ['He said "hello"', 'x\ty']
]);

Tabs at the edges encode empty cells. Calling trim() first would erase them. The parser also preserves spaces inside values.

The second check makes a deliberate boundary rule visible: one terminal record separator ends the preceding row; an additional separator represents an explicit blank row. Your application's policy might differ, but make it explicit and test it before dropping blank rows.

3. Valid rows do not always make valid objects

Two columns named SKU cannot both map to the same object property without losing one value. Parsing and object conversion are separate steps:

assert.throws(
  () => toRecords(parseClipboard('SKU\tSKU\r\n00123\t00456')),
  error => error.code === 'DUPLICATE_HEADER'
);

assert.throws(
  () => toRecords(parseClipboard('SKU\tNotes\r\n00123')),
  error => error.code === 'RAGGED_ROW'
);

console.log('All six clipboard checks passed.');

parseClipboard preserves ragged rows. toRecords requires exact, unique, nonblank headers and rows of matching width. It does not trim or rename headers. Keep the array representation if your application needs to resolve those cases interactively.

Connect a paste field

For a page with <textarea id="paste-input"></textarea> and <pre id="result"></pre>, serve index.mjs beside the page and put this in a module script:

import { parseClipboard } from './index.mjs';

const input = document.querySelector('#paste-input');
const output = document.querySelector('#result');

input.addEventListener('paste', event => {
  if (!event.clipboardData?.types.includes('text/plain')) return;
  event.preventDefault();

  try {
    const rows = parseClipboard(
      event.clipboardData.getData('text/plain'),
      { maxChars: 500_000, maxRows: 2_000, maxColumns: 80 }
    );
    output.textContent = JSON.stringify(rows, null, 2);
  } catch (error) {
    output.textContent = error.message;
  }
});

The handler reads only the current paste event's plain text and replaces the preview on success or failure. Use textContent so a cell containing HTML is displayed as text. The parser's maxChars limit counts UTF-16 code units, matching JavaScript's string length. Row and column limits apply to the parsed table.

MDN documents the event's clipboardData property and preventing default paste behavior. This example displays the parsed result; inserting cells into your grid, preserving selection and handling concurrent edits belong in your application's update layer.

Try it without setting up a project

The local browser playground is a ZIP containing a self-contained page. Extract it, open index.html, load the example or paste a range, and inspect arrays or header-based JSON objects. The page makes no uploads and needs no external runtime assets. Its preview shows up to 30 data rows and 8 columns; the JSON result includes the complete parsed table within the configured limits.

The source and API guide explain the exact grammar and include 31 parser/API tests with 144 deterministic round trips. Those tests verify text handling; they are not a compatibility matrix for every spreadsheet and browser version. Check a real copy/paste from the applications your users have.

This module does not interpret HTML clipboard data, read XLSX files, preserve styles or merged cells, or neutralize spreadsheet formulas. Its serializer preserves formula-looking strings, which a receiving spreadsheet may evaluate. If you already have a CSV/TSV parser, check its quoting, empty-row and type-conversion settings before adding another dependency.

Buy me a coffee, if this helped

If this saved you a little time, you're welcome to buy me a coffee. Please don't feel obliged — using the code, reporting an issue, or sharing it is appreciated too.

• USDC on Solana: 9tY6D9mwcFaJwwzEHvw2v7nhSpdjqjNBYtuooyBN6rYy
• USDC on Base: 0x568Ab98578d682FB0B0b45619BE73EbFfbf5a6eA

Please match the asset and network exactly. Fees depend on your wallet or exchange. Thank you! — Tevinch