Uncaught SyntaxError: Unexpected token < in JSON at position 0 : at JSON.parse (<anonymous>) at Object.<anonymous>

Uncaught SyntaxError: Unexpected token < in JSON at position 0 : at JSON.parse (<anonymous>) at Object.<anonymous>

  1. Blog
  2. 15 November 2026
  3. 3 min read

Stefan Bogdanescu

Founder & Senior Architect

The Hidden Cost of JSON.parse() on Unnecessary Data

Encountering the error Uncaught SyntaxError: Unexpected token < in JSON at position 0 is a classic symptom of a specific architectural misunderstanding in AJAX interactions. You are attempting to use JSON.parse() on data that hasn't been sent as raw JSON from the server, or worse, you are parsing HTML content that happens to start with an HTML comment or tag.

In your specific scenario, the error occurs because the PHP script is echoing the result of json_encode() directly to the browser. While this works in some legacy contexts, it violates the fundamental contract of modern AJAX requests. When a server sends data via HTTP, it must include the correct MIME type header (Content-Type: application/json). Without this header, browsers often default to treating the response as HTML text.

If your JavaScript receives a string that isn't valid JSON—perhaps because the browser tried to render it as an HTML page or if there's whitespace interference—the JSON.parse() method fails immediately at position 0. This is not a bug in your parser; it is a signal that the data format received does not match what you expect.

The Root Cause: Missing Headers and Echo Logic

The core issue lies in how the PHP file handles output. Currently, your PHP code executes echo request($conn); at the bottom of the script. This outputs the JSON string directly to the browser's response stream. However, there is no explicit header being set before this echo occurs.

Modern browsers and JavaScript engines are strict about MIME types. When you fetch a URL using $.ajax, jQuery checks the Content-Type header returned by the server. If that header is missing or incorrect (e.g., missing entirely), the browser might not treat the response as pure JSON. In many cases, if the PHP file is being accessed via a route that expects HTML, the web server might serve an error page or a wrapper template instead of just the raw string, causing JSON.parse to crash on the first character (often <).

To fix this, you must explicitly tell the browser what kind of data it is receiving. You need to add header('Content-Type: application/json'); at the very top of your PHP file, before any output is generated.

Correcting the PHP Implementation

Here is how your requestOffer.php should be structured to ensure a clean, parseable response:

<?php
// 1. Set the correct header first. This is non-negotiable for JSON responses.
header('Content-Type: application/json');

include_once("database_conn.php");

function request($conn)
{
    $eventstArray = array();

    // Note: Using mysqli_query directly on a query with ORDER BY 1 is fine,
    // but ensure you are fetching arrays correctly.
    $eventsQuery1 = mysqli_query($conn, $events) or die(mysqli_error($conn));

    while($row = mysqli_fetch_array($eventsQuery1))
    {
        $eventstArray[] = array(
            'label'         => $row['eventTitle'],
            'venue'         => $row['venueName'],
            'category'      => $row['catDesc'],
            'price'         => $row['eventPrice'],
            'description'   => $row['eventDescription']
        );
    }

    // Return the JSON string. Do not echo it here if you want to handle it via header only,
    // but since this is a script that outputs directly, we can let it fall through or return it.
    // However, for AJAX GET requests returning data directly, echoing the encoded string 
    // with the correct header is acceptable, provided no other output happens.
    return json_encode($eventstArray);
}

// Only echo if no other headers are set and we are in a direct request context.
// Ideally, move this logic into a class or controller pattern to separate concerns.
echo request($conn);
?>

Updating the JavaScript Client

While fixing the PHP side is crucial, your JavaScript also needs to be robust. You should verify that data exists before parsing it, and ensure you aren't accidentally trying to parse an HTML document.

$(document).ready(function() {
    'use strict';
    
    $.ajax({
        method: "get",
        url: "requestOffer.php",
        // Ensure jQuery sends the correct Accept header so the server knows what it wants
        dataType: 'json' 
    })
    .done(function(data) {
        // Optional: Validate that data is actually an array or object before parsing
        if (typeof data !== 'object') {
            console.error("Received unexpected data type:", typeof data);
            return;
        }

        var offers = data; // If dataType is set to 'json', jQuery handles the parse for you.

        $('#EOffers').autocomplete({
            minLength: 3,
            source: offers,
            select: function(event, ui) {
                $('#chosenEvent').text(ui.item.label);
                // Note: Corrected typo in source material 'vanue' -> 'venue'
                $('#chosenEvent').text(ui.item.venue); 
            }
        });
    })
    .fail(function(xhr) {
        console.error("AJAX failed", xhr.status, xhr.statusText);
        if (xhr.responseText.substring(0, 1) === '<') {
            console.warn("Server returned HTML instead of JSON.");
        }
    });
});

Key Takeaways for Development

  1. Always Set Headers First: Never rely on default content types. Always call header('Content-Type: application/json'); in PHP before any output, including whitespace.
  2. Leverage jQuery's dataType: In your AJAX call, set dataType: 'json'. When this is present, jQuery automatically attempts to parse the response using JSON.parse(). If it fails (e.g., because the server sent HTML), jQuery throws a specific error or leaves the result as a string depending on configuration. This prevents you from manually calling JSON.parse() on potentially malformed data inside your .done callback.
  3. Avoid Manual Parsing When Possible: Unless you have a strict requirement to handle raw strings, let the framework (jQuery in this case) handle the parsing. If the server sends HTML by mistake, jQuery will catch it, whereas manual JSON.parse() will throw an unhelpful syntax error.
  4. Watch Out for Typos: In your original JS, there was a typo: ui.item.vanue should be ui.item.venue. This would cause the autocomplete selection event to fail silently or crash depending on how jQuery handles undefined properties in older versions.

By aligning the server headers with client expectations and leveraging built-in parsing mechanisms, you eliminate the Unexpected token < error and create a more resilient data exchange pipeline. For developers looking to streamline this further, frameworks like Laravel provide robust methods for returning JSON responses automatically, ensuring headers are always correct without manual intervention.

Our network