API

Look an instruction up

Paths are relative to https://instructionsets.com.

{arch} is one of the names below. {slug} is the mnemonic in lower case with spaces, dots and slashes replaced by _, so ADD is add, PowerISA's add. is add_, and x86's rep movs is rep_movs. It is also the name of the instruction's page: /x86/add/ is /api/v1/x86/add.json. One character outside letters, digits and _ is in use, the + in PowerISA's blt+, so percent-encode the slug when you build a URL. The architecture listing gives every slug, so you never have to guess one.

What comes back

A lookup returns every record for the mnemonic, because one mnemonic is often several forms: ARM's add is 9 of them, and each has its own page, with the form's anchor on it. The record itself is the same one the dataset holds, field for field. Shortened here:

{
  "api_version": "1",
  "snapshot": "2026-10-08",
  "licence": "CC0-1.0",
  "architecture": "x86",
  "mnemonic": "add",
  "slug": "add",
  "records": [
    {
      "page": "https://instructionsets.com/x86/add/",
      "record": {
        "mnemonic": "add",
        "architecture": "x86",
        "full_name": "Add",
        "summary": "Adds src to dest and stores result in dest.",
        "syntax": "ADD r/m, r",
        "encoding": {
          "format": "Legacy",
          "hex_opcode": "01"
        },
        "...": "more fields, left out here"
      }
    }
  ]
}

Every record has mnemonic, architecture, full_name, summary, syntax, description, encoding, operands. Each architecture adds its own fields: GPU records carry data types and supported targets, AMDGPU records list the other names AMD gives the instruction in aliases (the architecture listing carries them too, so either name can be found), and PowerISA records carry extended mnemonics and special registers. The schema requires those and leaves the rest open.

Try it

curl -s https://instructionsets.com/api/v1/x86/add.json | jq '.records[0].record.summary'

JavaScript

In a browser or in Node 18 or later, as a module:

const API = "https://instructionsets.com/api/v1";

async function lookup(arch, mnemonic) {
  const slug = mnemonic.toLowerCase().replace(/[ ./]/g, "_");
  const res = await fetch(`${API}/${arch}/${encodeURIComponent(slug)}.json`);
  if (res.status === 404) return null;
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

const add = await lookup("x86", "ADD");
console.log(add.records[0].record.summary);

Python

With nothing but the standard library:

import json
import re
import urllib.error
import urllib.parse
import urllib.request

API = "https://instructionsets.com/api/v1"


def lookup(arch, mnemonic):
    slug = re.sub(r"[ ./]", "_", mnemonic.lower())
    url = f"{API}/{arch}/{urllib.parse.quote(slug)}.json"
    try:
        with urllib.request.urlopen(url) as response:
            return json.load(response)
    except urllib.error.HTTPError as err:
        if err.code == 404:
            return None
        raise


add = lookup("x86", "ADD")
print(add["records"][0]["record"]["summary"])

A 404 means there is no such mnemonic in that architecture. lookup returns nothing rather than failing, so a hover or a tooltip can simply not appear for a word that is not an instruction.

Give it to an AI agent

Any model that can call a function can look instructions up. This is a tool definition in Anthropic's format; other providers take the same schema under a different key. Implement it with the request above.

{
  "name": "lookup_instruction",
  "description": "Look up a CPU or GPU instruction by mnemonic and architecture.",
  "input_schema": {
    "type": "object",
    "properties": {
      "architecture": {
        "type": "string",
        "enum": [
          "x86",
          "arm",
          "powerisa",
          "risc-v",
          "ptx",
          "amdgpu"
        ]
      },
      "mnemonic": {
        "type": "string",
        "description": "For example ADD, vaddps or v_add_f32"
      }
    },
    "required": [
      "architecture",
      "mnemonic"
    ]
  }
}

The site also publishes llms.txt, an index written for language models to read.

Show it in an editor

A hover for assembly files in VS Code. It uses the language id of whichever extension provides your assembly highlighting, and looks the word under the cursor up on x86; change the architecture for another. This one is shown as written and has not been run here, since it needs the extension host.

import * as vscode from "vscode";

const API = "https://instructionsets.com/api/v1";

export function activate(context: vscode.ExtensionContext) {
  context.subscriptions.push(
    vscode.languages.registerHoverProvider({ language: "asm" }, {
      async provideHover(document, position) {
        const range = document.getWordRangeAtPosition(position);
        if (!range) return undefined;
        const word = document.getText(range).toLowerCase();
        const res = await fetch(`${API}/x86/${encodeURIComponent(word)}.json`);
        if (!res.ok) return undefined;
        const { records } = await res.json();
        const { summary, syntax } = records[0].record;
        const text = new vscode.MarkdownString(`\`${syntax}\`\n\n${summary}`);
        return new vscode.Hover(text);
      },
    }),
  );
}

How stable it is

This API is new and nothing is known to depend on it yet, so v1 can still change, including in ways that break a caller: a field renamed, moved or removed. Changes are listed on What's new, which has an RSS feed. The schema describes the shape as it is today.

• The content changes. Records are corrected, instructions are added, and counts move. snapshot is the date of the build that produced the file.
• A form is identified by its page URL. If a form's name is corrected, its anchor can change with it, and forms inside a lookup are not in a fixed order.

What it does not do

It looks up, and does not search. There is no query by opcode, operand or description. For that, use the site's search, or to take an instruction word apart, the decoder. The site also publishes search.json and decode.json, which are its own indexes: they are not part of this API, and their format can change without notice.

The files are served from GitHub Pages and cached for ten minutes. Please cache what you fetch. If you want everything, do not fetch all 6,087 files: download the dataset, which is the same records in one file.

Accuracy, and the licence

The records were extracted from vendor specifications by a language model and then repaired, and how far they can be trusted is measured and written down in ACCURACY.md. The API serves the dataset's own records, so everything that document says about the dataset is true of it. Text reproduced verbatim from vendor manuals is not in the dataset, and so is not here. Anything safety critical should be checked against the vendor's manual.

The data is CC0: use it for anything, commercially too, with no permission and no attribution. A link back to instructionsets.com is welcome and never a condition. Found a wrong record? Tell us.