felixcloutier APIfelixcloutier.com ↗
Access x86/amd64 instruction data: opcodes, pseudocode, flags, and exceptions for every instruction listed on felixcloutier.com.
What is the felixcloutier API?
This API exposes x86/amd64 instruction reference data from felixcloutier.com across 5 endpoints, covering every instruction in the index along with full per-instruction documentation. The get_instruction_detail endpoint returns opcode tables, operation pseudocode, operand encoding, flags affected, intrinsics, and exception tables for any mnemonic you provide. Two search endpoints let you filter by mnemonic substring or by summary keyword.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/5e838c46-f5f7-404c-b9e4-5bc1153a16fa/get_instruction_index' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace felixcloutier-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
from parse_apis.x86_instruction_reference_api import X86Ref, Instruction, InstructionDetail, OpcodeEntry
client = X86Ref()
# Search for arithmetic instructions by mnemonic substring
for instr in client.instructions.search_by_mnemonic(query="ADD"):
print(instr.mnemonic, instr.summary)
# Get full detail for a specific instruction
add_instr = client.instructions.get(mnemonic="ADD")
detail = add_instr.detail()
print(detail.title, detail.description)
# Get opcode table for the instruction
for opcode in add_instr.get_opcodes():
print(opcode.opcode, opcode.instruction, opcode.mode_64bit)
# Search instructions by what they do
for instr in client.instructions.search_by_summary(query="multiply"):
print(instr.mnemonic, instr.full_url)
Retrieves the complete index of x86/amd64 instructions. Each entry contains the mnemonic, a brief summary of what the instruction does, and the URL path to its detail page. The index is a single-page static list (no pagination).
No input parameters required.
{
"type": "object",
"fields": {
"items": "array of instruction summary objects with mnemonic, summary, path, and full_url"
},
"sample": {
"data": {
"items": [
{
"path": "/x86/aaa",
"summary": "ASCII Adjust After Addition",
"full_url": "https://www.felixcloutier.com/x86/aaa",
"mnemonic": "AAA"
},
{
"path": "/x86/add",
"summary": "Add",
"full_url": "https://www.felixcloutier.com/x86/add",
"mnemonic": "ADD"
}
]
},
"status": "success"
}
}About the felixcloutier API
Instruction Index and Search
The get_instruction_index endpoint returns the full instruction list with no required parameters. Each item in the response array includes a mnemonic, a plain-English summary, a relative path, and a full_url back to the source page. If you want a narrower result set, search_instructions_by_mnemonic accepts a query string and returns every instruction whose mnemonic contains that substring (case-insensitive). search_instructions_by_summary does the same match against the summary field — useful for finding all instructions related to a concept like "shift" or "compare" without knowing specific mnemonics.
Per-Instruction Detail
The get_instruction_detail endpoint accepts a single mnemonic parameter (case-insensitive) and returns a structured object with these fields: title, opcodes (the full opcode table), operand_encoding, description, operation (pseudocode as documented in the reference), flags_affected, intrinsics, and exceptions. This covers both the human-readable prose sections and the machine-readable tabular data in one response.
Opcode Table Only
When you only need encoding details, get_instruction_opcodes returns just the opcode rows for a given mnemonic. Each row includes columns like Opcode, Instruction, Op/En, 64-Bit Mode, Compat/Leg Mode, and Description. This is useful when you are building disassemblers, assemblers, or encoding validators and want a structured table without the surrounding documentation prose.
The felixcloutier API is a managed, monitored endpoint for felixcloutier.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when felixcloutier.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official felixcloutier.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a CLI tool that prints opcode encodings and mode support for any x86 mnemonic using
get_instruction_opcodes. - Populate an IDE plugin's inline documentation pane with instruction descriptions, pseudocode, and flags from
get_instruction_detail. - Generate a searchable offline instruction reference by pulling the full index via
get_instruction_indexand caching detail pages. - Cross-reference instruction exception tables when writing low-level fault handlers or hypervisor code.
- Find all instructions related to a hardware feature (e.g. "AES", "AVX") using
search_instructions_by_mnemonic. - Identify instructions that affect a specific flag by searching summaries with
search_instructions_by_summary. - Feed structured opcode data into an assembler test harness to verify encoding coverage against the reference.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does felixcloutier.com have an official developer API?+
What does `get_instruction_detail` return for the `operation` field?+
operation field contains the pseudocode block as it appears in the instruction documentation — the same algorithmic description used in Intel's official SDM. It is returned as a string and preserves the structure of the original reference text.Does the API cover EVEX-encoded (AVX-512) instructions and their opcode variants?+
get_instruction_opcodes include EVEX variants where they exist in the source. Instructions not present in the felixcloutier.com index are not returned.Can I retrieve the exception tables broken down by exception class or type?+
exceptions field in get_instruction_detail returns the exception data as documented per instruction, but the API does not expose a cross-instruction endpoint to query by exception class. You can fork this API on Parse and revise it to add a filtered exceptions endpoint that aggregates across instructions.Does the API support pagination for the instruction index?+
get_instruction_index returns the complete instruction list in a single response with no pagination parameters. The full index for x86 runs to several hundred entries, all returned at once. If you need server-side pagination, you can fork the API on Parse and revise it to add limit and offset parameters.