diff --git a/doc/source/user_guide/io.rst b/doc/source/user_guide/io.rst
index 90a8bd868b60b..84a78ace8d7c7 100644
--- a/doc/source/user_guide/io.rst
+++ b/doc/source/user_guide/io.rst
@@ -2111,7 +2111,8 @@ Reading from a JSON string:
 
 .. ipython:: python
 
-   pd.read_json(json)
+   from io import StringIO
+   pd.read_json(StringIO(json))
 
 Reading from a file:
 
@@ -2135,6 +2136,7 @@ Preserve string indices:
 
 .. ipython:: python
 
+   from io import StringIO
    si = pd.DataFrame(
        np.zeros((4, 4)), columns=list(range(4)), index=[str(i) for i in range(4)]
    )
@@ -2143,7 +2145,7 @@ Preserve string indices:
    si.columns
    json = si.to_json()
 
-   sij = pd.read_json(json, convert_axes=False)
+   sij = pd.read_json(StringIO(json), convert_axes=False)
    sij
    sij.index
    sij.columns
@@ -2152,18 +2154,19 @@ Dates written in nanoseconds need to be read back in nanoseconds:
 
 .. ipython:: python
 
+   from io import StringIO
    json = dfj2.to_json(date_unit="ns")
 
    # Try to parse timestamps as milliseconds -> Won't Work
-   dfju = pd.read_json(json, date_unit="ms")
+   dfju = pd.read_json(StringIO(json), date_unit="ms")
    dfju
 
    # Let pandas detect the correct precision
-   dfju = pd.read_json(json)
+   dfju = pd.read_json(StringIO(json))
    dfju
 
    # Or specify that all timestamps are in nanoseconds
-   dfju = pd.read_json(json, date_unit="ns")
+   dfju = pd.read_json(StringIO(json), date_unit="ns")
    dfju
 
 By setting the ``dtype_backend`` argument you can control the default dtypes used for the resulting DataFrame.
@@ -2251,11 +2254,12 @@ For line-delimited json files, pandas can also return an iterator which reads in
 
 .. ipython:: python
 
+  from io import StringIO
   jsonl = """
       {"a": 1, "b": 2}
       {"a": 3, "b": 4}
   """
-  df = pd.read_json(jsonl, lines=True)
+  df = pd.read_json(StringIO(jsonl), lines=True)
   df
   df.to_json(orient="records", lines=True)
 
diff --git a/doc/source/whatsnew/v1.5.0.rst b/doc/source/whatsnew/v1.5.0.rst
index badf3f0f68627..9653226b96196 100644
--- a/doc/source/whatsnew/v1.5.0.rst
+++ b/doc/source/whatsnew/v1.5.0.rst
@@ -474,19 +474,22 @@ upon serialization. (Related issue :issue:`12997`)
 
 .. code-block:: ipython
 
-    In [4]: a.to_json(date_format='iso')
-    Out[4]: '{"2020-12-28T00:00:00.000Z":0,"2020-12-28T01:00:00.000Z":1,"2020-12-28T02:00:00.000Z":2}'
+    In [4]: from io import StringIO
 
-    In [5]: pd.read_json(a.to_json(date_format='iso'), typ="series").index == a.index
-    Out[5]: array([False, False, False])
+    In [5]: a.to_json(date_format='iso')
+    Out[5]: '{"2020-12-28T00:00:00.000Z":0,"2020-12-28T01:00:00.000Z":1,"2020-12-28T02:00:00.000Z":2}'
+
+    In [6]: pd.read_json(StringIO(a.to_json(date_format='iso')), typ="series").index == a.index
+    Out[6]: array([False, False, False])
 
 *New Behavior*
 
 .. ipython:: python
 
+    from io import StringIO
     a.to_json(date_format='iso')
     # Roundtripping now works
-    pd.read_json(a.to_json(date_format='iso'), typ="series").index == a.index
+    pd.read_json(StringIO(a.to_json(date_format='iso')), typ="series").index == a.index
 
 .. _whatsnew_150.notable_bug_fixes.groupby_value_counts_categorical:
 
diff --git a/doc/source/whatsnew/v2.1.0.rst b/doc/source/whatsnew/v2.1.0.rst
index 42b1346696bb8..eaca68822ee5d 100644
--- a/doc/source/whatsnew/v2.1.0.rst
+++ b/doc/source/whatsnew/v2.1.0.rst
@@ -287,6 +287,7 @@ Deprecations
 - Deprecated behavior of :func:`assert_series_equal` and :func:`assert_frame_equal` considering NA-like values (e.g. ``NaN`` vs ``None`` as equivalent) (:issue:`52081`)
 - Deprecated constructing :class:`SparseArray` from scalar data, pass a sequence instead (:issue:`53039`)
 - Deprecated falling back to filling when ``value`` is not specified in :meth:`DataFrame.replace` and :meth:`Series.replace` with non-dict-like ``to_replace`` (:issue:`33302`)
+- Deprecated literal json input to :func:`read_json`. Wrap literal json string input in ``io.StringIO`` instead. (:issue:`53409`)
 - Deprecated option "mode.use_inf_as_na", convert inf entries to ``NaN`` before instead (:issue:`51684`)
 - Deprecated positional indexing on :class:`Series` with :meth:`Series.__getitem__` and :meth:`Series.__setitem__`, in a future version ``ser[item]`` will *always* interpret ``item`` as a label, not a position (:issue:`50617`)
 - Deprecated the "method" and "limit" keywords on :meth:`Series.fillna`, :meth:`DataFrame.fillna`, :meth:`SeriesGroupBy.fillna`, :meth:`DataFrameGroupBy.fillna`, and :meth:`Resampler.fillna`, use ``obj.bfill()`` or ``obj.ffill()`` instead (:issue:`53394`)
diff --git a/pandas/io/json/_json.py b/pandas/io/json/_json.py
index 5c2fba814375f..eaeaedfdddfcb 100644
--- a/pandas/io/json/_json.py
+++ b/pandas/io/json/_json.py
@@ -18,6 +18,7 @@
     TypeVar,
     overload,
 )
+import warnings
 
 import numpy as np
 
@@ -30,6 +31,7 @@
 from pandas.compat._optional import import_optional_dependency
 from pandas.errors import AbstractMethodError
 from pandas.util._decorators import doc
+from pandas.util._exceptions import find_stack_level
 from pandas.util._validators import check_dtype_backend
 
 from pandas.core.dtypes.common import ensure_str
@@ -535,6 +537,10 @@ def read_json(
         By file-like object, we refer to objects with a ``read()`` method,
         such as a file handle (e.g. via builtin ``open`` function)
         or ``StringIO``.
+
+        .. deprecated:: 2.1.0
+            Passing json literal strings is deprecated.
+
     orient : str, optional
         Indication of expected JSON string format.
         Compatible JSON strings can be produced by ``to_json()`` with a
@@ -695,6 +701,7 @@ def read_json(
 
     Examples
     --------
+    >>> from io import StringIO
     >>> df = pd.DataFrame([['a', 'b'], ['c', 'd']],
     ...                   index=['row 1', 'row 2'],
     ...                   columns=['col 1', 'col 2'])
@@ -709,7 +716,7 @@ def read_json(
 "data":[["a","b"],["c","d"]]\
 }}\
 '
-    >>> pd.read_json(_, orient='split')
+    >>> pd.read_json(StringIO(_), orient='split')
           col 1 col 2
     row 1     a     b
     row 2     c     d
@@ -719,7 +726,7 @@ def read_json(
     >>> df.to_json(orient='index')
     '{{"row 1":{{"col 1":"a","col 2":"b"}},"row 2":{{"col 1":"c","col 2":"d"}}}}'
 
-    >>> pd.read_json(_, orient='index')
+    >>> pd.read_json(StringIO(_), orient='index')
           col 1 col 2
     row 1     a     b
     row 2     c     d
@@ -729,7 +736,7 @@ def read_json(
 
     >>> df.to_json(orient='records')
     '[{{"col 1":"a","col 2":"b"}},{{"col 1":"c","col 2":"d"}}]'
-    >>> pd.read_json(_, orient='records')
+    >>> pd.read_json(StringIO(_), orient='records')
       col 1 col 2
     0     a     b
     1     c     d
@@ -860,6 +867,18 @@ def __init__(
             self.nrows = validate_integer("nrows", self.nrows, 0)
             if not self.lines:
                 raise ValueError("nrows can only be passed if lines=True")
+        if (
+            isinstance(filepath_or_buffer, str)
+            and not self.lines
+            and "\n" in filepath_or_buffer
+        ):
+            warnings.warn(
+                "Passing literal json to 'read_json' is deprecated and "
+                "will be removed in a future version. To read from a "
+                "literal string, wrap it in a 'StringIO' object.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
         if self.engine == "pyarrow":
             if not self.lines:
                 raise ValueError(
@@ -925,7 +944,14 @@ def _get_data_from_filepath(self, filepath_or_buffer):
             and not file_exists(filepath_or_buffer)
         ):
             raise FileNotFoundError(f"File {filepath_or_buffer} does not exist")
-
+        else:
+            warnings.warn(
+                "Passing literal json to 'read_json' is deprecated and "
+                "will be removed in a future version. To read from a "
+                "literal string, wrap it in a 'StringIO' object.",
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
         return filepath_or_buffer
 
     def _combine_lines(self, lines) -> str:
diff --git a/pandas/tests/io/json/test_compression.py b/pandas/tests/io/json/test_compression.py
index 4a7606eaf05d7..bbb34c0cdab3c 100644
--- a/pandas/tests/io/json/test_compression.py
+++ b/pandas/tests/io/json/test_compression.py
@@ -1,4 +1,7 @@
-from io import BytesIO
+from io import (
+    BytesIO,
+    StringIO,
+)
 
 import pytest
 
@@ -22,7 +25,8 @@ def test_compression_roundtrip(compression):
         # explicitly ensure file was compressed.
         with tm.decompress_file(path, compression) as fh:
             result = fh.read().decode("utf8")
-        tm.assert_frame_equal(df, pd.read_json(result))
+            data = StringIO(result)
+        tm.assert_frame_equal(df, pd.read_json(data))
 
 
 def test_read_zipped_json(datapath):
@@ -39,8 +43,7 @@ def test_read_zipped_json(datapath):
 @pytest.mark.single_cpu
 def test_with_s3_url(compression, s3_resource, s3so):
     # Bucket "pandas-test" created in tests/io/conftest.py
-
-    df = pd.read_json('{"a": [1, 2, 3], "b": [4, 5, 6]}')
+    df = pd.read_json(StringIO('{"a": [1, 2, 3], "b": [4, 5, 6]}'))
 
     with tm.ensure_clean() as path:
         df.to_json(path, compression=compression)
@@ -55,7 +58,7 @@ def test_with_s3_url(compression, s3_resource, s3so):
 
 def test_lines_with_compression(compression):
     with tm.ensure_clean() as path:
-        df = pd.read_json('{"a": [1, 2, 3], "b": [4, 5, 6]}')
+        df = pd.read_json(StringIO('{"a": [1, 2, 3], "b": [4, 5, 6]}'))
         df.to_json(path, orient="records", lines=True, compression=compression)
         roundtripped_df = pd.read_json(path, lines=True, compression=compression)
         tm.assert_frame_equal(df, roundtripped_df)
@@ -63,7 +66,7 @@ def test_lines_with_compression(compression):
 
 def test_chunksize_with_compression(compression):
     with tm.ensure_clean() as path:
-        df = pd.read_json('{"a": ["foo", "bar", "baz"], "b": [4, 5, 6]}')
+        df = pd.read_json(StringIO('{"a": ["foo", "bar", "baz"], "b": [4, 5, 6]}'))
         df.to_json(path, orient="records", lines=True, compression=compression)
 
         with pd.read_json(
@@ -74,7 +77,7 @@ def test_chunksize_with_compression(compression):
 
 
 def test_write_unsupported_compression_type():
-    df = pd.read_json('{"a": [1, 2, 3], "b": [4, 5, 6]}')
+    df = pd.read_json(StringIO('{"a": [1, 2, 3], "b": [4, 5, 6]}'))
     with tm.ensure_clean() as path:
         msg = "Unrecognized compression type: unsupported"
         with pytest.raises(ValueError, match=msg):
diff --git a/pandas/tests/io/json/test_deprecated_kwargs.py b/pandas/tests/io/json/test_deprecated_kwargs.py
index 7e3296db75323..cc88fc3ba1826 100644
--- a/pandas/tests/io/json/test_deprecated_kwargs.py
+++ b/pandas/tests/io/json/test_deprecated_kwargs.py
@@ -1,6 +1,7 @@
 """
 Tests for the deprecated keyword arguments for `read_json`.
 """
+from io import StringIO
 
 import pandas as pd
 import pandas._testing as tm
@@ -10,9 +11,11 @@
 
 def test_good_kwargs():
     df = pd.DataFrame({"A": [2, 4, 6], "B": [3, 6, 9]}, index=[0, 1, 2])
+
     with tm.assert_produces_warning(None):
-        tm.assert_frame_equal(df, read_json(df.to_json(orient="split"), orient="split"))
-        tm.assert_frame_equal(
-            df, read_json(df.to_json(orient="columns"), orient="columns")
-        )
-        tm.assert_frame_equal(df, read_json(df.to_json(orient="index"), orient="index"))
+        data1 = StringIO(df.to_json(orient="split"))
+        tm.assert_frame_equal(df, read_json(data1, orient="split"))
+        data2 = StringIO(df.to_json(orient="columns"))
+        tm.assert_frame_equal(df, read_json(data2, orient="columns"))
+        data3 = StringIO(df.to_json(orient="index"))
+        tm.assert_frame_equal(df, read_json(data3, orient="index"))
diff --git a/pandas/tests/io/json/test_json_table_schema.py b/pandas/tests/io/json/test_json_table_schema.py
index 48ab0f1be8c4a..25b0e4a9f1de9 100644
--- a/pandas/tests/io/json/test_json_table_schema.py
+++ b/pandas/tests/io/json/test_json_table_schema.py
@@ -1,5 +1,6 @@
 """Tests for Table Schema integration."""
 from collections import OrderedDict
+from io import StringIO
 import json
 
 import numpy as np
@@ -254,7 +255,8 @@ def test_read_json_from_to_json_results(self):
                 "name_en": {"row_0": "Hakata Dolls Matsuo"},
             }
         )
-        result1 = pd.read_json(df.to_json())
+
+        result1 = pd.read_json(StringIO(df.to_json()))
         result2 = DataFrame.from_dict(json.loads(df.to_json()))
         tm.assert_frame_equal(result1, df)
         tm.assert_frame_equal(result2, df)
@@ -794,7 +796,7 @@ def test_comprehensive(self):
             index=pd.Index(range(4), name="idx"),
         )
 
-        out = df.to_json(orient="table")
+        out = StringIO(df.to_json(orient="table"))
         result = pd.read_json(out, orient="table")
         tm.assert_frame_equal(df, result)
 
@@ -810,7 +812,7 @@ def test_multiindex(self, index_names):
             columns=["Aussprache", "Griechisch", "Args"],
         )
         df.index.names = index_names
-        out = df.to_json(orient="table")
+        out = StringIO(df.to_json(orient="table"))
         result = pd.read_json(out, orient="table")
         tm.assert_frame_equal(df, result)
 
@@ -818,7 +820,7 @@ def test_empty_frame_roundtrip(self):
         # GH 21287
         df = DataFrame(columns=["a", "b", "c"])
         expected = df.copy()
-        out = df.to_json(orient="table")
+        out = StringIO(df.to_json(orient="table"))
         result = pd.read_json(out, orient="table")
         tm.assert_frame_equal(expected, result)
 
@@ -841,5 +843,5 @@ def test_read_json_orient_table_old_schema_version(self):
         }
         """
         expected = DataFrame({"a": [1, 2.0, "s"]})
-        result = pd.read_json(df_json, orient="table")
+        result = pd.read_json(StringIO(df_json), orient="table")
         tm.assert_frame_equal(expected, result)
diff --git a/pandas/tests/io/json/test_json_table_schema_ext_dtype.py b/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
index 75845148f6581..b7bb057bc538e 100644
--- a/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
+++ b/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
@@ -3,6 +3,7 @@
 from collections import OrderedDict
 import datetime as dt
 import decimal
+from io import StringIO
 import json
 
 import pytest
@@ -287,7 +288,7 @@ def test_json_ext_dtype_reading_roundtrip(self):
         )
         expected = df.copy()
         data_json = df.to_json(orient="table", indent=4)
-        result = read_json(data_json, orient="table")
+        result = read_json(StringIO(data_json), orient="table")
         tm.assert_frame_equal(result, expected)
 
     def test_json_ext_dtype_reading(self):
@@ -311,6 +312,6 @@ def test_json_ext_dtype_reading(self):
                 }
             ]
         }"""
-        result = read_json(data_json, orient="table")
+        result = read_json(StringIO(data_json), orient="table")
         expected = DataFrame({"a": Series([2, NA], dtype="Int64")})
         tm.assert_frame_equal(result, expected)
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index a966ad1dabcaa..48b6870743d8b 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -29,6 +29,51 @@
 )
 
 
+def test_literal_json_deprecation():
+    # PR 53409
+    expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
+
+    jsonl = """{"a": 1, "b": 2}
+        {"a": 3, "b": 4}
+        {"a": 5, "b": 6}
+        {"a": 7, "b": 8}"""
+
+    msg = (
+        "Passing literal json to 'read_json' is deprecated and "
+        "will be removed in a future version. To read from a "
+        "literal string, wrap it in a 'StringIO' object."
+    )
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        try:
+            read_json(jsonl, lines=False)
+        except ValueError:
+            pass
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        read_json(expected.to_json(), lines=False)
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = read_json('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n', lines=True)
+        tm.assert_frame_equal(result, expected)
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        try:
+            result = read_json(
+                '{"a\\\\":"foo\\\\","b":"bar"}\n{"a\\\\":"foo\\"","b":"bar"}\n',
+                lines=False,
+            )
+        except ValueError:
+            pass
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        try:
+            result = read_json('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n', lines=False)
+        except ValueError:
+            pass
+        tm.assert_frame_equal(result, expected)
+
+
 def assert_json_roundtrip_equal(result, expected, orient):
     if orient in ("records", "values"):
         expected = expected.reset_index(drop=True)
@@ -74,15 +119,16 @@ def test_frame_double_encoded_labels(self, orient):
             columns=["a \\ b", "y / z"],
         )
 
-        result = read_json(df.to_json(orient=orient), orient=orient)
+        data = StringIO(df.to_json(orient=orient))
+        result = read_json(data, orient=orient)
         expected = df.copy()
-
         assert_json_roundtrip_equal(result, expected, orient)
 
     @pytest.mark.parametrize("orient", ["split", "records", "values"])
     def test_frame_non_unique_index(self, orient):
         df = DataFrame([["a", "b"], ["c", "d"]], index=[1, 1], columns=["x", "y"])
-        result = read_json(df.to_json(orient=orient), orient=orient)
+        data = StringIO(df.to_json(orient=orient))
+        result = read_json(data, orient=orient)
         expected = df.copy()
 
         assert_json_roundtrip_equal(result, expected, orient)
@@ -108,7 +154,7 @@ def test_frame_non_unique_columns(self, orient, data):
         df = DataFrame(data, index=[1, 2], columns=["x", "x"])
 
         result = read_json(
-            df.to_json(orient=orient), orient=orient, convert_dates=["x"]
+            StringIO(df.to_json(orient=orient)), orient=orient, convert_dates=["x"]
         )
         if orient == "values":
             expected = DataFrame(data)
@@ -138,7 +184,7 @@ def test_frame_default_orient(self, float_frame):
     @pytest.mark.parametrize("dtype", [False, float])
     @pytest.mark.parametrize("convert_axes", [True, False])
     def test_roundtrip_simple(self, orient, convert_axes, dtype, float_frame):
-        data = float_frame.to_json(orient=orient)
+        data = StringIO(float_frame.to_json(orient=orient))
         result = read_json(data, orient=orient, convert_axes=convert_axes, dtype=dtype)
 
         expected = float_frame
@@ -148,7 +194,7 @@ def test_roundtrip_simple(self, orient, convert_axes, dtype, float_frame):
     @pytest.mark.parametrize("dtype", [False, np.int64])
     @pytest.mark.parametrize("convert_axes", [True, False])
     def test_roundtrip_intframe(self, orient, convert_axes, dtype, int_frame):
-        data = int_frame.to_json(orient=orient)
+        data = StringIO(int_frame.to_json(orient=orient))
         result = read_json(data, orient=orient, convert_axes=convert_axes, dtype=dtype)
         expected = int_frame
         assert_json_roundtrip_equal(result, expected, orient)
@@ -163,7 +209,7 @@ def test_roundtrip_str_axes(self, orient, convert_axes, dtype):
             dtype=dtype,
         )
 
-        data = df.to_json(orient=orient)
+        data = StringIO(df.to_json(orient=orient))
         result = read_json(data, orient=orient, convert_axes=convert_axes, dtype=dtype)
 
         expected = df.copy()
@@ -197,8 +243,7 @@ def test_roundtrip_categorical(
                 )
             )
 
-        data = categorical_frame.to_json(orient=orient)
-
+        data = StringIO(categorical_frame.to_json(orient=orient))
         result = read_json(data, orient=orient, convert_axes=convert_axes)
 
         expected = categorical_frame.copy()
@@ -209,7 +254,7 @@ def test_roundtrip_categorical(
     @pytest.mark.parametrize("convert_axes", [True, False])
     def test_roundtrip_empty(self, orient, convert_axes):
         empty_frame = DataFrame()
-        data = empty_frame.to_json(orient=orient)
+        data = StringIO(empty_frame.to_json(orient=orient))
         result = read_json(data, orient=orient, convert_axes=convert_axes)
         if orient == "split":
             idx = pd.Index([], dtype=(float if convert_axes else object))
@@ -224,7 +269,7 @@ def test_roundtrip_empty(self, orient, convert_axes):
     @pytest.mark.parametrize("convert_axes", [True, False])
     def test_roundtrip_timestamp(self, orient, convert_axes, datetime_frame):
         # TODO: improve coverage with date_format parameter
-        data = datetime_frame.to_json(orient=orient)
+        data = StringIO(datetime_frame.to_json(orient=orient))
         result = read_json(data, orient=orient, convert_axes=convert_axes)
         expected = datetime_frame.copy()
 
@@ -250,7 +295,7 @@ def test_roundtrip_mixed(self, orient, convert_axes):
 
         df = DataFrame(data=values, index=index)
 
-        data = df.to_json(orient=orient)
+        data = StringIO(df.to_json(orient=orient))
         result = read_json(data, orient=orient, convert_axes=convert_axes)
 
         expected = df.copy()
@@ -275,9 +320,8 @@ def test_roundtrip_multiindex(self, columns):
             [[1, 2], [3, 4]],
             columns=pd.MultiIndex.from_arrays(columns),
         )
-
-        result = read_json(df.to_json(orient="split"), orient="split")
-
+        data = StringIO(df.to_json(orient="split"))
+        result = read_json(data, orient="split")
         tm.assert_frame_equal(result, df)
 
     @pytest.mark.parametrize(
@@ -322,8 +366,9 @@ def test_frame_from_json_bad_data_raises(self, data, msg, orient):
     @pytest.mark.parametrize("convert_axes", [True, False])
     def test_frame_from_json_missing_data(self, orient, convert_axes, dtype):
         num_df = DataFrame([[1, 2], [4, 5, 6]])
+
         result = read_json(
-            num_df.to_json(orient=orient),
+            StringIO(num_df.to_json(orient=orient)),
             orient=orient,
             convert_axes=convert_axes,
             dtype=dtype,
@@ -332,7 +377,7 @@ def test_frame_from_json_missing_data(self, orient, convert_axes, dtype):
 
         obj_df = DataFrame([["1", "2"], ["4", "5", "6"]])
         result = read_json(
-            obj_df.to_json(orient=orient),
+            StringIO(obj_df.to_json(orient=orient)),
             orient=orient,
             convert_axes=convert_axes,
             dtype=dtype,
@@ -343,7 +388,7 @@ def test_frame_from_json_missing_data(self, orient, convert_axes, dtype):
     def test_frame_read_json_dtype_missing_value(self, dtype):
         # GH28501 Parse missing values using read_json with dtype=False
         # to NaN instead of None
-        result = read_json("[null]", dtype=dtype)
+        result = read_json(StringIO("[null]"), dtype=dtype)
         expected = DataFrame([np.nan])
 
         tm.assert_frame_equal(result, expected)
@@ -355,7 +400,9 @@ def test_frame_infinity(self, inf, dtype):
         # deserialisation
         df = DataFrame([[1, 2], [4, 5, 6]])
         df.loc[0, 2] = inf
-        result = read_json(df.to_json(), dtype=dtype)
+
+        data = StringIO(df.to_json())
+        result = read_json(data, dtype=dtype)
         assert np.isnan(result.iloc[0, 2])
 
     @pytest.mark.skipif(not IS64, reason="not compliant on 32-bit, xref #15865")
@@ -384,8 +431,12 @@ def test_frame_to_json_except(self):
     def test_frame_empty(self):
         df = DataFrame(columns=["jim", "joe"])
         assert not df._is_mixed_type
+
+        data = StringIO(df.to_json())
         tm.assert_frame_equal(
-            read_json(df.to_json(), dtype=dict(df.dtypes)), df, check_index_type=False
+            read_json(data, dtype=dict(df.dtypes)),
+            df,
+            check_index_type=False,
         )
         # GH 7445
         result = DataFrame({"test": []}, index=[]).to_json(orient="columns")
@@ -397,8 +448,11 @@ def test_frame_empty_mixedtype(self):
         df = DataFrame(columns=["jim", "joe"])
         df["joe"] = df["joe"].astype("i8")
         assert df._is_mixed_type
+        data = df.to_json()
         tm.assert_frame_equal(
-            read_json(df.to_json(), dtype=dict(df.dtypes)), df, check_index_type=False
+            read_json(StringIO(data), dtype=dict(df.dtypes)),
+            df,
+            check_index_type=False,
         )
 
     def test_frame_mixedtype_orient(self):  # GH10289
@@ -417,17 +471,17 @@ def test_frame_mixedtype_orient(self):  # GH10289
         right = df.copy()
 
         for orient in ["split", "index", "columns"]:
-            inp = df.to_json(orient=orient)
+            inp = StringIO(df.to_json(orient=orient))
             left = read_json(inp, orient=orient, convert_axes=False)
             tm.assert_frame_equal(left, right)
 
         right.index = pd.RangeIndex(len(df))
-        inp = df.to_json(orient="records")
+        inp = StringIO(df.to_json(orient="records"))
         left = read_json(inp, orient="records", convert_axes=False)
         tm.assert_frame_equal(left, right)
 
         right.columns = pd.RangeIndex(df.shape[1])
-        inp = df.to_json(orient="values")
+        inp = StringIO(df.to_json(orient="values"))
         left = read_json(inp, orient="values", convert_axes=False)
         tm.assert_frame_equal(left, right)
 
@@ -546,8 +600,8 @@ def test_blocks_compat_GH9037(self):
 
         # JSON deserialisation always creates unicode strings
         df_mixed.columns = df_mixed.columns.astype("unicode")
-
-        df_roundtrip = read_json(df_mixed.to_json(orient="split"), orient="split")
+        data = StringIO(df_mixed.to_json(orient="split"))
+        df_roundtrip = read_json(data, orient="split")
         tm.assert_frame_equal(
             df_mixed,
             df_roundtrip,
@@ -609,10 +663,13 @@ def test_series_non_unique_index(self):
             s.to_json(orient="index")
 
         tm.assert_series_equal(
-            s, read_json(s.to_json(orient="split"), orient="split", typ="series")
+            s,
+            read_json(
+                StringIO(s.to_json(orient="split")), orient="split", typ="series"
+            ),
         )
         unserialized = read_json(
-            s.to_json(orient="records"), orient="records", typ="series"
+            StringIO(s.to_json(orient="records")), orient="records", typ="series"
         )
         tm.assert_numpy_array_equal(s.values, unserialized.values)
 
@@ -620,7 +677,7 @@ def test_series_default_orient(self, string_series):
         assert string_series.to_json() == string_series.to_json(orient="index")
 
     def test_series_roundtrip_simple(self, orient, string_series):
-        data = string_series.to_json(orient=orient)
+        data = StringIO(string_series.to_json(orient=orient))
         result = read_json(data, typ="series", orient=orient)
 
         expected = string_series
@@ -633,7 +690,7 @@ def test_series_roundtrip_simple(self, orient, string_series):
 
     @pytest.mark.parametrize("dtype", [False, None])
     def test_series_roundtrip_object(self, orient, dtype, object_series):
-        data = object_series.to_json(orient=orient)
+        data = StringIO(object_series.to_json(orient=orient))
         result = read_json(data, typ="series", orient=orient, dtype=dtype)
 
         expected = object_series
@@ -646,7 +703,7 @@ def test_series_roundtrip_object(self, orient, dtype, object_series):
 
     def test_series_roundtrip_empty(self, orient):
         empty_series = Series([], index=[], dtype=np.float64)
-        data = empty_series.to_json(orient=orient)
+        data = StringIO(empty_series.to_json(orient=orient))
         result = read_json(data, typ="series", orient=orient)
 
         expected = empty_series.reset_index(drop=True)
@@ -656,7 +713,7 @@ def test_series_roundtrip_empty(self, orient):
         tm.assert_series_equal(result, expected)
 
     def test_series_roundtrip_timeseries(self, orient, datetime_series):
-        data = datetime_series.to_json(orient=orient)
+        data = StringIO(datetime_series.to_json(orient=orient))
         result = read_json(data, typ="series", orient=orient)
 
         expected = datetime_series
@@ -670,7 +727,7 @@ def test_series_roundtrip_timeseries(self, orient, datetime_series):
     @pytest.mark.parametrize("dtype", [np.float64, int])
     def test_series_roundtrip_numeric(self, orient, dtype):
         s = Series(range(6), index=["a", "b", "c", "d", "e", "f"])
-        data = s.to_json(orient=orient)
+        data = StringIO(s.to_json(orient=orient))
         result = read_json(data, typ="series", orient=orient)
 
         expected = s.copy()
@@ -687,13 +744,13 @@ def test_series_to_json_except(self):
 
     def test_series_from_json_precise_float(self):
         s = Series([4.56, 4.56, 4.56])
-        result = read_json(s.to_json(), typ="series", precise_float=True)
+        result = read_json(StringIO(s.to_json()), typ="series", precise_float=True)
         tm.assert_series_equal(result, s, check_index_type=False)
 
     def test_series_with_dtype(self):
         # GH 21986
         s = Series([4.56, 4.56, 4.56])
-        result = read_json(s.to_json(), typ="series", dtype=np.int64)
+        result = read_json(StringIO(s.to_json()), typ="series", dtype=np.int64)
         expected = Series([4] * 3)
         tm.assert_series_equal(result, expected)
 
@@ -706,28 +763,27 @@ def test_series_with_dtype(self):
     )
     def test_series_with_dtype_datetime(self, dtype, expected):
         s = Series(["2000-01-01"], dtype="datetime64[ns]")
-        data = s.to_json()
+        data = StringIO(s.to_json())
         result = read_json(data, typ="series", dtype=dtype)
         tm.assert_series_equal(result, expected)
 
     def test_frame_from_json_precise_float(self):
         df = DataFrame([[4.56, 4.56, 4.56], [4.56, 4.56, 4.56]])
-        result = read_json(df.to_json(), precise_float=True)
+        result = read_json(StringIO(df.to_json()), precise_float=True)
         tm.assert_frame_equal(result, df)
 
     def test_typ(self):
         s = Series(range(6), index=["a", "b", "c", "d", "e", "f"], dtype="int64")
-        result = read_json(s.to_json(), typ=None)
+        result = read_json(StringIO(s.to_json()), typ=None)
         tm.assert_series_equal(result, s)
 
     def test_reconstruction_index(self):
         df = DataFrame([[1, 2, 3], [4, 5, 6]])
-        result = read_json(df.to_json())
-
+        result = read_json(StringIO(df.to_json()))
         tm.assert_frame_equal(result, df)
 
         df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}, index=["A", "B", "C"])
-        result = read_json(df.to_json())
+        result = read_json(StringIO(df.to_json()))
         tm.assert_frame_equal(result, df)
 
     def test_path(self, float_frame, int_frame, datetime_frame):
@@ -738,12 +794,12 @@ def test_path(self, float_frame, int_frame, datetime_frame):
 
     def test_axis_dates(self, datetime_series, datetime_frame):
         # frame
-        json = datetime_frame.to_json()
+        json = StringIO(datetime_frame.to_json())
         result = read_json(json)
         tm.assert_frame_equal(result, datetime_frame)
 
         # series
-        json = datetime_series.to_json()
+        json = StringIO(datetime_series.to_json())
         result = read_json(json, typ="series")
         tm.assert_series_equal(result, datetime_series, check_names=False)
         assert result.name is None
@@ -753,12 +809,12 @@ def test_convert_dates(self, datetime_series, datetime_frame):
         df = datetime_frame
         df["date"] = Timestamp("20130101").as_unit("ns")
 
-        json = df.to_json()
+        json = StringIO(df.to_json())
         result = read_json(json)
         tm.assert_frame_equal(result, df)
 
         df["foo"] = 1.0
-        json = df.to_json(date_unit="ns")
+        json = StringIO(df.to_json(date_unit="ns"))
 
         result = read_json(json, convert_dates=False)
         expected = df.copy()
@@ -768,7 +824,7 @@ def test_convert_dates(self, datetime_series, datetime_frame):
 
         # series
         ts = Series(Timestamp("20130101").as_unit("ns"), index=datetime_series.index)
-        json = ts.to_json()
+        json = StringIO(ts.to_json())
         result = read_json(json, typ="series")
         tm.assert_series_equal(result, ts)
 
@@ -815,7 +871,8 @@ def test_convert_dates_infer(self, infer_word):
         expected = DataFrame(
             [[1, Timestamp("2002-11-08")], [2, pd.NaT]], columns=["id", infer_word]
         )
-        result = read_json(dumps(data))[["id", infer_word]]
+
+        result = read_json(StringIO(dumps(data)))[["id", infer_word]]
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
@@ -838,7 +895,8 @@ def test_date_format_frame(self, date, date_unit, datetime_frame):
             json = df.to_json(date_format="iso", date_unit=date_unit)
         else:
             json = df.to_json(date_format="iso")
-        result = read_json(json)
+
+        result = read_json(StringIO(json))
         expected = df.copy()
         tm.assert_frame_equal(result, expected)
 
@@ -866,7 +924,8 @@ def test_date_format_series(self, date, date_unit, datetime_series):
             json = ts.to_json(date_format="iso", date_unit=date_unit)
         else:
             json = ts.to_json(date_format="iso")
-        result = read_json(json, typ="series")
+
+        result = read_json(StringIO(json), typ="series")
         expected = ts.copy()
         tm.assert_series_equal(result, expected)
 
@@ -888,11 +947,11 @@ def test_date_unit(self, unit, datetime_frame):
         json = df.to_json(date_format="epoch", date_unit=unit)
 
         # force date unit
-        result = read_json(json, date_unit=unit)
+        result = read_json(StringIO(json), date_unit=unit)
         tm.assert_frame_equal(result, df)
 
         # detect date unit
-        result = read_json(json, date_unit=None)
+        result = read_json(StringIO(json), date_unit=None)
         tm.assert_frame_equal(result, df)
 
     def test_weird_nested_json(self):
@@ -914,8 +973,7 @@ def test_weird_nested_json(self):
            ]
           }
         }"""
-
-        read_json(s)
+        read_json(StringIO(s))
 
     def test_doc_example(self):
         dfj2 = DataFrame(np.random.randn(5, 2), columns=list("AB"))
@@ -924,7 +982,7 @@ def test_doc_example(self):
         dfj2["bools"] = True
         dfj2.index = pd.date_range("20130101", periods=5)
 
-        json = dfj2.to_json()
+        json = StringIO(dfj2.to_json())
         result = read_json(json, dtype={"ints": np.int64, "bools": np.bool_})
         tm.assert_frame_equal(result, result)
 
@@ -933,7 +991,8 @@ def test_round_trip_exception(self, datapath):
         path = datapath("io", "json", "data", "teams.csv")
         df = pd.read_csv(path)
         s = df.to_json()
-        result = read_json(s)
+
+        result = read_json(StringIO(s))
         res = result.reindex(index=df.index, columns=df.columns)
         res = res.fillna(np.nan, downcast=False)
         tm.assert_frame_equal(res, df)
@@ -962,17 +1021,19 @@ def test_timedelta(self):
         ser = Series([timedelta(23), timedelta(seconds=5)])
         assert ser.dtype == "timedelta64[ns]"
 
-        result = read_json(ser.to_json(), typ="series").apply(converter)
+        result = read_json(StringIO(ser.to_json()), typ="series").apply(converter)
         tm.assert_series_equal(result, ser)
 
         ser = Series([timedelta(23), timedelta(seconds=5)], index=pd.Index([0, 1]))
         assert ser.dtype == "timedelta64[ns]"
-        result = read_json(ser.to_json(), typ="series").apply(converter)
+        result = read_json(StringIO(ser.to_json()), typ="series").apply(converter)
         tm.assert_series_equal(result, ser)
 
         frame = DataFrame([timedelta(23), timedelta(seconds=5)])
         assert frame[0].dtype == "timedelta64[ns]"
-        tm.assert_frame_equal(frame, read_json(frame.to_json()).apply(converter))
+        tm.assert_frame_equal(
+            frame, read_json(StringIO(frame.to_json())).apply(converter)
+        )
 
     def test_timedelta2(self):
         frame = DataFrame(
@@ -982,8 +1043,8 @@ def test_timedelta2(self):
                 "c": pd.date_range(start="20130101", periods=2),
             }
         )
-
-        result = read_json(frame.to_json(date_unit="ns"))
+        data = StringIO(frame.to_json(date_unit="ns"))
+        result = read_json(data)
         result["a"] = pd.to_timedelta(result.a, unit="ns")
         result["c"] = pd.to_datetime(result.c)
         tm.assert_frame_equal(frame, result)
@@ -996,7 +1057,8 @@ def test_mixed_timedelta_datetime(self):
         expected = DataFrame(
             {"a": [pd.Timedelta(td).as_unit("ns")._value, ts.as_unit("ns")._value]}
         )
-        result = read_json(frame.to_json(date_unit="ns"), dtype={"a": "int64"})
+        data = StringIO(frame.to_json(date_unit="ns"))
+        result = read_json(data, dtype={"a": "int64"})
         tm.assert_frame_equal(result, expected, check_index_type=False)
 
     @pytest.mark.parametrize("as_object", [True, False])
@@ -1026,7 +1088,7 @@ def test_default_handler(self):
         value = object()
         frame = DataFrame({"a": [7, value]})
         expected = DataFrame({"a": [7, str(value)]})
-        result = read_json(frame.to_json(default_handler=str))
+        result = read_json(StringIO(frame.to_json(default_handler=str)))
         tm.assert_frame_equal(expected, result, check_index_type=False)
 
     def test_default_handler_indirect(self):
@@ -1198,7 +1260,8 @@ def test_tz_range_is_naive(self):
 
     def test_read_inline_jsonl(self):
         # GH9180
-        result = read_json('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n', lines=True)
+
+        result = read_json(StringIO('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n'), lines=True)
         expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
         tm.assert_frame_equal(result, expected)
 
@@ -1234,7 +1297,7 @@ def test_read_jsonl_unicode_chars(self):
         tm.assert_frame_equal(result, expected)
 
         # simulate string
-        json = '{"a": "foo”", "b": "bar"}\n{"a": "foo", "b": "bar"}\n'
+        json = StringIO('{"a": "foo”", "b": "bar"}\n{"a": "foo", "b": "bar"}\n')
         result = read_json(json, lines=True)
         expected = DataFrame([["foo\u201d", "bar"], ["foo", "bar"]], columns=["a", "b"])
         tm.assert_frame_equal(result, expected)
@@ -1289,14 +1352,15 @@ def test_to_jsonl(self):
         result = df.to_json(orient="records", lines=True)
         expected = '{"a":"foo}","b":"bar"}\n{"a":"foo\\"","b":"bar"}\n'
         assert result == expected
-        tm.assert_frame_equal(read_json(result, lines=True), df)
+        tm.assert_frame_equal(read_json(StringIO(result), lines=True), df)
 
         # GH15096: escaped characters in columns and data
         df = DataFrame([["foo\\", "bar"], ['foo"', "bar"]], columns=["a\\", "b"])
         result = df.to_json(orient="records", lines=True)
         expected = '{"a\\\\":"foo\\\\","b":"bar"}\n{"a\\\\":"foo\\"","b":"bar"}\n'
         assert result == expected
-        tm.assert_frame_equal(read_json(result, lines=True), df)
+
+        tm.assert_frame_equal(read_json(StringIO(result), lines=True), df)
 
     # TODO: there is a near-identical test for pytables; can we share?
     @pytest.mark.xfail(reason="GH#13774 encoding kwarg not supported", raises=TypeError)
@@ -1327,7 +1391,7 @@ def test_latin_encoding(self):
         def roundtrip(s, encoding="latin-1"):
             with tm.ensure_clean("test.json") as path:
                 s.to_json(path, encoding=encoding)
-                retr = read_json(path, encoding=encoding)
+                retr = read_json(StringIO(path), encoding=encoding)
                 tm.assert_series_equal(s, retr, check_categorical=False)
 
         for s in examples:
@@ -1351,14 +1415,15 @@ def test_from_json_to_json_table_index_and_columns(self, index, columns):
         # GH25433 GH25435
         expected = DataFrame([[1, 2], [3, 4]], index=index, columns=columns)
         dfjson = expected.to_json(orient="table")
-        result = read_json(dfjson, orient="table")
+
+        result = read_json(StringIO(dfjson), orient="table")
         tm.assert_frame_equal(result, expected)
 
     def test_from_json_to_json_table_dtypes(self):
         # GH21345
         expected = DataFrame({"a": [1, 2], "b": [3.0, 4.0], "c": ["5", "6"]})
         dfjson = expected.to_json(orient="table")
-        result = read_json(dfjson, orient="table")
+        result = read_json(StringIO(dfjson), orient="table")
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("orient", ["split", "records", "index", "columns"])
@@ -1377,8 +1442,9 @@ def test_to_json_from_json_columns_dtypes(self, orient):
             }
         )
         dfjson = expected.to_json(orient=orient)
+
         result = read_json(
-            dfjson,
+            StringIO(dfjson),
             orient=orient,
             dtype={
                 "Integer": "int64",
@@ -1405,8 +1471,7 @@ def test_read_json_table_empty_axes_dtype(self, orient):
         # GH28558
 
         expected = DataFrame()
-        result = read_json("{}", orient=orient, convert_axes=True)
-
+        result = read_json(StringIO("{}"), orient=orient, convert_axes=True)
         tm.assert_index_equal(result.index, expected.index)
         tm.assert_index_equal(result.columns, expected.columns)
 
@@ -1519,13 +1584,13 @@ def test_index_false_from_json_to_json(self, orient, index):
         # Test index=False in from_json to_json
         expected = DataFrame({"a": [1, 2], "b": [3, 4]})
         dfjson = expected.to_json(orient=orient, index=index)
-        result = read_json(dfjson, orient=orient)
+        result = read_json(StringIO(dfjson), orient=orient)
         tm.assert_frame_equal(result, expected)
 
     def test_read_timezone_information(self):
         # GH 25546
         result = read_json(
-            '{"2019-01-01T11:00:00.000Z":88}', typ="series", orient="index"
+            StringIO('{"2019-01-01T11:00:00.000Z":88}'), typ="series", orient="index"
         )
         expected = Series([88], index=DatetimeIndex(["2019-01-01 11:00:00"], tz="UTC"))
         tm.assert_series_equal(result, expected)
@@ -1541,7 +1606,7 @@ def test_read_timezone_information(self):
     )
     def test_read_json_with_url_value(self, url):
         # GH 36271
-        result = read_json(f'{{"url":{{"0":"{url}"}}}}')
+        result = read_json(StringIO(f'{{"url":{{"0":"{url}"}}}}'))
         expected = DataFrame({"url": [url]})
         tm.assert_frame_equal(result, expected)
 
@@ -1746,7 +1811,9 @@ def test_json_negative_indent_raises(self):
 
     def test_emca_262_nan_inf_support(self):
         # GH 12213
-        data = '["a", NaN, "NaN", Infinity, "Infinity", -Infinity, "-Infinity"]'
+        data = StringIO(
+            '["a", NaN, "NaN", Infinity, "Infinity", -Infinity, "-Infinity"]'
+        )
         result = read_json(data)
         expected = DataFrame(
             ["a", None, "NaN", np.inf, "Infinity", -np.inf, "-Infinity"]
@@ -1757,7 +1824,7 @@ def test_frame_int_overflow(self):
         # GH 30320
         encoded_json = json.dumps([{"col": "31900441201190696999"}, {"col": "Text"}])
         expected = DataFrame({"col": ["31900441201190696999", "Text"]})
-        result = read_json(encoded_json)
+        result = read_json(StringIO(encoded_json))
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
@@ -1802,7 +1869,7 @@ def test_json_pandas_nulls(self, nulls_fixture, request):
 
     def test_readjson_bool_series(self):
         # GH31464
-        result = read_json("[true, true, false]", typ="series")
+        result = read_json(StringIO("[true, true, false]"), typ="series")
         expected = Series([True, True, False])
         tm.assert_series_equal(result, expected)
 
@@ -1918,7 +1985,9 @@ def test_read_json_dtype_backend(self, string_storage, dtype_backend, orient):
 
         out = df.to_json(orient=orient)
         with pd.option_context("mode.string_storage", string_storage):
-            result = read_json(out, dtype_backend=dtype_backend, orient=orient)
+            result = read_json(
+                StringIO(out), dtype_backend=dtype_backend, orient=orient
+            )
 
         expected = DataFrame(
             {
@@ -1957,7 +2026,7 @@ def test_read_json_nullable_series(self, string_storage, dtype_backend, orient):
         out = ser.to_json(orient=orient)
         with pd.option_context("mode.string_storage", string_storage):
             result = read_json(
-                out, dtype_backend=dtype_backend, orient=orient, typ="series"
+                StringIO(out), dtype_backend=dtype_backend, orient=orient, typ="series"
             )
 
         expected = Series([1, np.nan, 3], dtype="Int64")
diff --git a/pandas/tests/io/json/test_readlines.py b/pandas/tests/io/json/test_readlines.py
index 7d7614bc93845..54f4980b1e4e3 100644
--- a/pandas/tests/io/json/test_readlines.py
+++ b/pandas/tests/io/json/test_readlines.py
@@ -23,7 +23,7 @@ def lines_json_df():
 
 def test_read_jsonl():
     # GH9180
-    result = read_json('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n', lines=True)
+    result = read_json(StringIO('{"a": 1, "b": 2}\n{"b":2, "a" :1}\n'), lines=True)
     expected = DataFrame([[1, 2], [1, 2]], columns=["a", "b"])
     tm.assert_frame_equal(result, expected)
 
@@ -50,7 +50,11 @@ def test_read_datetime(request, engine):
         columns=["accounts", "date", "name"],
     )
     json_line = df.to_json(lines=True, orient="records")
-    result = read_json(json_line, engine=engine)
+
+    if engine == "pyarrow":
+        result = read_json(StringIO(json_line), engine=engine)
+    else:
+        result = read_json(StringIO(json_line), engine=engine)
     expected = DataFrame(
         [[1, "2020-03-05", "hector"], [2, "2020-04-08T09:58:49+00:00", "hector"]],
         columns=["accounts", "date", "name"],
@@ -71,7 +75,7 @@ def test_read_jsonl_unicode_chars():
 
     # simulate string
     json = '{"a": "foo”", "b": "bar"}\n{"a": "foo", "b": "bar"}\n'
-    result = read_json(json, lines=True)
+    result = read_json(StringIO(json), lines=True)
     expected = DataFrame([["foo\u201d", "bar"], ["foo", "bar"]], columns=["a", "b"])
     tm.assert_frame_equal(result, expected)
 
@@ -87,14 +91,14 @@ def test_to_jsonl():
     result = df.to_json(orient="records", lines=True)
     expected = '{"a":"foo}","b":"bar"}\n{"a":"foo\\"","b":"bar"}\n'
     assert result == expected
-    tm.assert_frame_equal(read_json(result, lines=True), df)
+    tm.assert_frame_equal(read_json(StringIO(result), lines=True), df)
 
     # GH15096: escaped characters in columns and data
     df = DataFrame([["foo\\", "bar"], ['foo"', "bar"]], columns=["a\\", "b"])
     result = df.to_json(orient="records", lines=True)
     expected = '{"a\\\\":"foo\\\\","b":"bar"}\n{"a\\\\":"foo\\"","b":"bar"}\n'
     assert result == expected
-    tm.assert_frame_equal(read_json(result, lines=True), df)
+    tm.assert_frame_equal(read_json(StringIO(result), lines=True), df)
 
 
 def test_to_jsonl_count_new_lines():
@@ -256,7 +260,7 @@ def test_readjson_chunks_multiple_empty_lines(chunksize):
     {"A":3,"B":6}
     """
     orig = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
-    test = read_json(j, lines=True, chunksize=chunksize)
+    test = read_json(StringIO(j), lines=True, chunksize=chunksize)
     if chunksize is not None:
         with test:
             test = pd.concat(test)
@@ -290,7 +294,7 @@ def test_readjson_nrows(nrows, engine):
         {"a": 3, "b": 4}
         {"a": 5, "b": 6}
         {"a": 7, "b": 8}"""
-    result = read_json(jsonl, lines=True, nrows=nrows)
+    result = read_json(StringIO(jsonl), lines=True, nrows=nrows)
     expected = DataFrame({"a": [1, 3, 5, 7], "b": [2, 4, 6, 8]}).iloc[:nrows]
     tm.assert_frame_equal(result, expected)
 
@@ -311,10 +315,17 @@ def test_readjson_nrows_chunks(request, nrows, chunksize, engine):
         {"a": 3, "b": 4}
         {"a": 5, "b": 6}
         {"a": 7, "b": 8}"""
-    with read_json(
-        jsonl, lines=True, nrows=nrows, chunksize=chunksize, engine=engine
-    ) as reader:
-        chunked = pd.concat(reader)
+
+    if engine != "pyarrow":
+        with read_json(
+            StringIO(jsonl), lines=True, nrows=nrows, chunksize=chunksize, engine=engine
+        ) as reader:
+            chunked = pd.concat(reader)
+    else:
+        with read_json(
+            jsonl, lines=True, nrows=nrows, chunksize=chunksize, engine=engine
+        ) as reader:
+            chunked = pd.concat(reader)
     expected = DataFrame({"a": [1, 3, 5, 7], "b": [2, 4, 6, 8]}).iloc[:nrows]
     tm.assert_frame_equal(chunked, expected)