# An internal error occurred and the request could not be completed > BigQuery failed on its own side and says so with HTTP 500 and the reason internalError. Most of the time a retry with backoff works. If the same query fails the same way every time, the query is the trigger and the retry will not help. Source: https://docs.querylab.io/bigquery-errors/an-internal-error-occurred-and-the-request-could-not-be-completed/ Updated: 2026-11-04 ```text An internal error occurred and the request could not be completed. This is usually caused by a transient issue. Retrying the job with back-off as described in the BigQuery SLA should solve the problem: https://cloud.google.com/bigquery/sla. If the error continues to occur please contact support at https://cloud.google.com/support. Error: 41416439 ``` ## What BigQuery means Something failed inside BigQuery, and it is not your SQL as far as BigQuery can tell. The API answers with HTTP 500 and the reason `internalError`. BigQuery's documentation for that reason says to wait according to the back-off rules in the Service Level Agreement and try again, and to contact support if the error continues. It adds that you can reduce how often it happens by using reservations. The message ends with a number. It is the only detail the error gives, so keep the whole message when you ask for help. Most of the time the retry works. Sometimes it does not, because the query itself sets the error off. The example below fails the same way every time. ## A query that always fails ```sql SELECT 1 AS _FIELD_2, 2 AS _field_x ``` A dry run of this query returned the message at the top of the page, with the number `41416439`. We repeated the dry run four times over about 50 seconds, waiting longer each time, and got the same message and the same number every time. The query has nothing wrong with its syntax or its tables. Running the same query for real returned a normal error that names the problem: ```text Duplicate field '_field_2' ``` The reason for that one is `invalidQuery`, HTTP 400. `SELECT STRUCT(1 AS _FIELD_2, 2) AS s` behaves the same way: an internal error on the dry run, and `Duplicate field 's._field_2'` on a run. Both queries gave these results on 2026-11-04. BigQuery may have fixed this since, so read the example as one case of an internal error that a query causes. The cause is a naming rule. BigQuery replaces a column name that starts with `_field_` by `_field_` and the column's position. In the real run, `_field_x` in the second column became `_field_2`, which is the first column's name `_FIELD_2` when case is ignored. In `SELECT 1 AS _field_x, 2 AS _FIELD_2` the first column was renamed to `_field_1` and the query ran. ## The fixes 1. **Retry with backoff.** Wait, try again, and wait longer after each failure. This is what the message and the documentation ask for, and it is right for an error that comes and goes. 2. **If the same query fails every time, stop retrying.** Take the query apart. Remove a column, a join or a function at a time until it runs, and the last thing you removed is the trigger. Then write that part another way. 3. **Contact support** if it keeps happening. The message says so. Give them the whole message, the job ID and the query. Retry only a query that is safe to run twice. A failed `SELECT` is. A script that failed part way has already done its earlier statements. ## Related reasons The API uses other reasons for the same kind of failure. These come from the BigQuery documentation: | Reason | HTTP code | Meaning | | ------------------ | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `internalError` | 500 | An internal error within BigQuery. Retry with backoff. | | `backendError` | 500, 502, 503, 504 | The service is unavailable for a short time. Causes include a surge in demand, network problems and load shedding. Retry with truncated exponential backoff. | | `jobInternalError` | 400 | The job was created, then failed with an internal error. Retry the job with a new job ID. | | `jobBackendError` | 400 | The job was created, then failed with an internal error. Retry with a new job ID. | `rateLimitExceeded` is also temporary and is retried the same way. See [Exceeded rate limits: too many table update operations](https://docs.querylab.io/bigquery-errors/exceeded-rate-limits-too-many-table-update-operations/). ## Different errors that look like this one An error that names a cause is not an internal error. `Resources exceeded during query execution` means the query was too heavy for its slot, and a retry will not change that. See [Resources exceeded: allotted memory](https://docs.querylab.io/bigquery-errors/resources-exceeded-allotted-memory/). ## In Querylab.io Querylab.io treats `internalError`, `backendError`, `rateLimitExceeded` and the three `job...` variants as temporary failures. When a run of a single `SELECT` fails with one of them, the status bar shows BigQuery's message and offers **Try again**, which runs the query once more. The button does not appear for a script, a DML or DDL statement, or an error from a dry run. A dry-run error shows the message and has no one-click fix. ## Sources Based on the BigQuery documentation by Google, CC BY 4.0, rewritten with examples checked against BigQuery: - [Error messages](https://cloud.google.com/bigquery/docs/error-messages) - [BigQuery Service Level Agreement](https://cloud.google.com/bigquery/sla)