Skip to main content

​
Overview

Output parsers transform raw language model outputs into structured, typed data. They handle parsing, validation, and error recovery.

​
StringOutputParser

Extracts string content from AI messages. Import: 
import { StringOutputParser } from "@langchain/core/output_parsers";
Example: 
import { ChatOpenAI } from "@langchain/openai";
import { StringOutputParser } from "@langchain/core/output_parsers";

const model = new ChatOpenAI();
const parser = new StringOutputParser();

const chain = model.pipe(parser);

const result = await chain.invoke([["human", "Tell me a joke"]]);
// Returns: "Why did the chicken cross the road?..."

​
StructuredOutputParser

Parse output into a structured format using a Zod schema. 
import { StructuredOutputParser } from "@langchain/core/output_parsers";
import { z } from "zod";

const parser = StructuredOutputParser.fromZodSchema(
  z.object({
    name: z.string().describe("Person's name"),
    age: z.number().describe("Person's age"),
    email: z.string().email().describe("Email address")
  })
);

const formatInstructions = parser.getFormatInstructions();

const prompt = ChatPromptTemplate.fromTemplate(
  "Extract person info from the text.\n{format_instructions}\n{text}"
);

const chain = prompt.pipe(model).pipe(parser);

const result = await chain.invoke({
  text: "John Doe is 30 and can be reached at [email protected]",
  format_instructions: formatInstructions
});
// { name: "John Doe", age: 30, email: "[email protected]" }

​
JsonOutputParser

Parse JSON output from models. 
import { JsonOutputParser } from "@langchain/core/output_parsers";

const parser = new JsonOutputParser();

const prompt = ChatPromptTemplate.fromTemplate(
  "Return a JSON object with these fields: name, age, city.\n{input}"
);

const chain = prompt.pipe(model).pipe(parser);

const result = await chain.invoke({
  input: "Alice is 25 and lives in Paris"
});
// { name: "Alice", age: 25, city: "Paris" }

​
CommaSeparatedListOutputParser

Parse comma-separated values into an array. 
import { CommaSeparatedListOutputParser } from "@langchain/core/output_parsers";

const parser = new CommaSeparatedListOutputParser();

const prompt = ChatPromptTemplate.fromTemplate(
  "List 5 {topic}. Return as comma-separated values."
);

const chain = prompt.pipe(model).pipe(parser);

const result = await chain.invoke({ topic: "colors" });
// ["red", "blue", "green", "yellow", "purple"]

​
Output Fixing Parser

Automatically fix malformed output using another LLM call. 
import { OutputFixingParser } from "langchain/output_parsers";
import { StructuredOutputParser } from "@langchain/core/output_parsers";

const baseParser = StructuredOutputParser.fromZodSchema(
  z.object({
    name: z.string(),
    age: z.number()
  })
);

const fixingParser = OutputFixingParser.fromLLM(model, baseParser);

// Even if model returns malformed JSON, fixing parser will correct it
const result = await fixingParser.parse(
  '{name: "Alice" age: 25}' // Missing comma
);
// { name: "Alice", age: 25 }

​
Custom Output Parser

Create custom parsers for specific needs: 
import { BaseOutputParser } from "@langchain/core/output_parsers";

class CustomParser extends BaseOutputParser<string[]> {
  lc_namespace = ["custom", "parsers"];

  async parse(text: string): Promise<string[]> {
    return text
      .split("\n")
      .filter(line => line.trim().length > 0)
      .map(line => line.trim());
  }

  getFormatInstructions(): string {
    return "Return each item on a new line.";
  }
}

const parser = new CustomParser();

​
Using with Structured Output

Modern chat models support native structured output, which is more reliable: 
import { ChatOpenAI } from "@langchain/openai";
import { z } from "zod";

const model = new ChatOpenAI();

const schema = z.object({
  name: z.string(),
  age: z.number(),
  hobbies: z.array(z.string())
});

const structuredModel = model.withStructuredOutput(schema);

const result = await structuredModel.invoke([
  ["human", "Tell me about Alice who is 25 and likes reading and hiking"]
]);
// Typed result matching the schema

​
Format Instructions

Most parsers provide format instructions to include in prompts: 
const parser = StructuredOutputParser.fromZodSchema(schema);
const instructions = parser.getFormatInstructions();

const prompt = ChatPromptTemplate.fromTemplate(
  "Extract information:\n{format_instructions}\n{input}"
);

const chain = prompt.pipe(model).pipe(parser);

​
Error Handling

import { OutputParserException } from "@langchain/core/output_parsers";

try {
  const result = await parser.parse(modelOutput);
} catch (error) {
  if (error instanceof OutputParserException) {
    console.error("Failed to parse output:", error.message);
    // Handle parsing error
  }
}

​
Parser Methods

​
parse
method
Parse the output string into structured format
async parse(text: string): Promise<T>
​
getFormatInstructions
method
Get instructions to include in the prompt
getFormatInstructions(): string
​
parseResult
method
Parse from a chat generation result
async parseResult(generations: ChatGeneration[]): Promise<T>

​
Best Practices

Modern models support withStructuredOutput which is more reliable:
const structured = model.withStructuredOutput(schema);
Always include the parser’s format instructions:
const instructions = parser.getFormatInstructions();
Use Zod for runtime type safety:
const schema = z.object({ ... }).strict();

Chat Models

Using structured output with chat models

Prompts

Using parsers with prompts

Build docs developers (and LLMs) love

Get started for freeTalk to us