Update the rows matching a filter

curl --request PATCH \
  --url https://api.paigeme.dev/v1/tables/{table}/rows \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "values": {},
  "filters": [
    {
      "column": "<string>",
      "value": "<string>"
    }
  ]
}
'

const options = {
  method: 'PATCH',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({values: {}, filters: [{column: '<string>', value: '<string>'}]})
};

fetch('https://api.paigeme.dev/v1/tables/{table}/rows', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

import requests

url = "https://api.paigeme.dev/v1/tables/{table}/rows"

payload = {
    "values": {},
    "filters": [
        {
            "column": "<string>",
            "value": "<string>"
        }
    ]
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.patch(url, json=payload, headers=headers)

print(response.text)

{
  "success": true,
  "data": {
    "table": "<string>",
    "schema": "<string>",
    "updated": 123,
    "rows": [
      {}
    ]
  }
}

{
  "success": false,
  "error": {
    "code": "invalid_request",
    "message": "Invalid request body",
    "details": {}
  },
  "request_id": "<string>"
}

{
  "success": false,
  "error": {
    "code": "invalid_request",
    "message": "Invalid request body",
    "details": {}
  },
  "request_id": "<string>"
}

{
  "success": false,
  "error": {
    "code": "invalid_request",
    "message": "Invalid request body",
    "details": {}
  },
  "request_id": "<string>"
}

{
  "success": false,
  "error": {
    "code": "invalid_request",
    "message": "Invalid request body",
    "details": {}
  },
  "request_id": "<string>"
}

{
  "success": false,
  "error": {
    "code": "invalid_request",
    "message": "Invalid request body",
    "details": {}
  },
  "request_id": "<string>"
}

{
  "success": false,
  "error": {
    "code": "invalid_request",
    "message": "Invalid request body",
    "details": {}
  },
  "request_id": "<string>"
}

{
  "success": false,
  "error": {
    "code": "invalid_request",
    "message": "Invalid request body",
    "details": {}
  },
  "request_id": "<string>"
}

Update the rows matching a filter

A partial patch of every row matching filters: only the columns in values are written, the rest are left alone. Returns the updated rows as stored.

filters is required and must be non-empty. Paige does not run an unconstrained UPDATE over this API — an empty or missing filter is 400, not a whole-table write. Predicates are AND-joined; up to 20. Ops: eq, neq, gt, gte, lt, lte, is.

like and ilike are read-only and are rejected here (400 filter_op_not_allowed). A pattern match has no bounded row set — like with a % pattern can match the whole table and looks no different from a narrow one — so Paige will not write through one. Read the rows you mean from GET /v1/tables/{table}/rows, then update them by primary key.

values must set at least one column (400 empty_payload).

Primary-key columns cannot be changed (400 primary_key_immutable) — delete the row and insert a replacement instead. Every other column you name is checked against the table’s real columns (400 unknown_column).

A column whose name collides with a reserved database query parameter (select, order, limit, offset, columns, and, or, not, on_conflict) cannot be used as a filter column — the predicate would be silently discarded, so it is refused with 400 reserved_filter_column.

Defaults to the public (production) schema.

A Paige platform table is 403 platform_table_forbidden; an unknown table is 404 table_not_found.

Only base tables are addressable. A view (or any other non-table relation) answers the same 404 table_not_found an unknown name does — including a view defined over a Paige platform table, which would otherwise be a writable alias for it.

Required scope: tables:write

PATCH

tables

{table}

rows

Update the rows matching a filter

curl --request PATCH \
  --url https://api.paigeme.dev/v1/tables/{table}/rows \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "values": {},
  "filters": [
    {
      "column": "<string>",
      "value": "<string>"
    }
  ]
}
'

const options = {
  method: 'PATCH',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({values: {}, filters: [{column: '<string>', value: '<string>'}]})
};

fetch('https://api.paigeme.dev/v1/tables/{table}/rows', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

import requests

url = "https://api.paigeme.dev/v1/tables/{table}/rows"

payload = {
    "values": {},
    "filters": [
        {
            "column": "<string>",
            "value": "<string>"
        }
    ]
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.patch(url, json=payload, headers=headers)

print(response.text)

{
  "success": true,
  "data": {
    "table": "<string>",
    "schema": "<string>",
    "updated": 123,
    "rows": [
      {}
    ]
  }
}

{
  "success": false,
  "error": {
    "code": "invalid_request",
    "message": "Invalid request body",
    "details": {}
  },
  "request_id": "<string>"
}

{
  "success": false,
  "error": {
    "code": "invalid_request",
    "message": "Invalid request body",
    "details": {}
  },
  "request_id": "<string>"
}

{
  "success": false,
  "error": {
    "code": "invalid_request",
    "message": "Invalid request body",
    "details": {}
  },
  "request_id": "<string>"
}

{
  "success": false,
  "error": {
    "code": "invalid_request",
    "message": "Invalid request body",
    "details": {}
  },
  "request_id": "<string>"
}

{
  "success": false,
  "error": {
    "code": "invalid_request",
    "message": "Invalid request body",
    "details": {}
  },
  "request_id": "<string>"
}

{
  "success": false,
  "error": {
    "code": "invalid_request",
    "message": "Invalid request body",
    "details": {}
  },
  "request_id": "<string>"
}

{
  "success": false,
  "error": {
    "code": "invalid_request",
    "message": "Invalid request body",
    "details": {}
  },
  "request_id": "<string>"
}

Authorizations

Authorization

string

header

required

Project API key issued in Settings → API keys. Send it as Authorization: Bearer pk_live_….

Headers

X-Paige-Project

string

Target project id, for an MCP OAuth bearer (mcp_at_…) attached to more than one project — get ids from GET /v1/projects. Matched case-insensitively.

Omit it and a READ falls back to the connection's default project; a mutation (any non-GET) on a connection with 2+ projects is rejected with 400 project_required — a write is never defaulted to a guessed project. A connection with exactly one project never needs the header.

Scopes are checked against the SELECTED project only, never a union across the connection.

For a pk_ API key the header selects nothing — one key is one project's context — but it IS validated: omit it and the key's own project is used, send it and it must name that project, otherwise the call is rejected with 403 project_not_attached (a blank value is 400 invalid_project_header, as above).

Path Parameters

table

string

required

Table name. Lowercase letters, digits and underscores only. Paige platform tables are rejected.

Pattern: ^[a-z_][a-z0-9_]{0,62}$

Body

application/json

values

object

required

Columns to set on every matched row, at least one. A partial patch — columns you omit are left unchanged.

Hide child attributes

values.{key}

A column value: string, number, boolean, null, or a JSON object/array for json/jsonb columns.

filters

object[]

required

Which rows to affect. REQUIRED and non-empty: 1-20 AND-joined predicates. Ops: eq, neq, gt, gte, lt, lte, is — like/ilike are read-only. An unfiltered update or delete is rejected, never executed against the whole table.

Hide child attributes

filters.column

string

required

Column name. Must be a column that actually exists on the table.

Pattern: ^[a-z_][a-z0-9_]{0,62}$

filters.op

enum<string>

required

Comparison operator. like and ilike are NOT accepted on an update or delete — pattern-matched writes are refused; read the rows first, then write by key.

Available options:

eq,

neq,

gt,

gte,

lt,

lte,

is

filters.value

required

Value to compare against. Only op "is" accepts null (or the string "null") — every other op rejects it, so use is to match NULL. With op "is" only null, true or false are accepted; with "like"/"ilike" it is a SQL LIKE pattern ("%" and "_" are the wildcards).

schema

enum<string>

Which database schema to target: "public" (production, the default) or "preview" (dev sandbox).

Available options:

public,

preview

Response

Success.

success

enum<boolean>

required

Available options:

true

data

object

required

Hide child attributes

data.table

string

required

data.schema

string

required

data.updated

number

required

How many rows matched the filters and were updated.

data.rows

object[]

required

The updated rows as stored.

Hide child attributes

data.rows.{key}

any

Getting started

Endpoints

Update the rows matching a filter

Authorizations

Headers

Path Parameters

Body

Response