> ## Documentation Index
> Fetch the complete documentation index at: https://doc.lucidworks.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Asynchronous Field Parser Index Stage

export const schema = {
  "type": "object",
  "title": "Asynchronous Field Parser",
  "description": "This stage sends field contents to async-parsing service for processing using specified index profile. Enables parallel document parsing and transformation without blocking main indexing pipeline. Particularly useful for large binary files, complex document formats, or when applying specialized parsers that may take significant processing time.",
  "required": ["profileId"],
  "properties": {
    "skip": {
      "type": "boolean",
      "title": "Skip This Stage",
      "description": "Controls whether this stage executes during pipeline processing at runtime. When set to `true`, the stage is completely bypassed and documents pass through unchanged to the next stage. Useful for A/B testing, gradual rollouts, or temporarily disabling a stage without removing it from the pipeline.",
      "default": false,
      "hints": ["advanced"]
    },
    "label": {
      "type": "string",
      "title": "Label",
      "description": "Human-readable identifier displayed in the Fusion Admin UI, monitoring dashboards, and log messages. Use descriptive labels like `Parse Product PDFs` to aid debugging and team collaboration. Labels appear in performance metrics and error reports, making it easier to identify which stage failed.",
      "hints": ["advanced"],
      "maxLength": 255
    },
    "condition": {
      "type": "string",
      "title": "Condition",
      "description": "JavaScript expression evaluated at runtime on each document to conditionally execute this stage. The expression must return `true` to execute or `false` to skip. Access document fields using `doc.getFieldValue('fieldName')` and request parameters via `request.getFirstParam('paramName')`. For example, `doc.getFieldValue('type') === 'premium'` executes this stage only for premium content.",
      "hints": ["code", "code/javascript", "advanced"]
    },
    "sourceField": {
      "type": "string",
      "title": "Source Field",
      "description": "Name of the document field from which content is read for parsing or transformation. Field names are case-sensitive and must exactly match the document schema, for example, use `content` or `title`. If the field doesn't exist, behavior depends on error handling configuration.",
      "default": "_raw_content_"
    },
    "sourceEncoding": {
      "type": "string",
      "title": "Source Field Encoding",
      "description": "Specifies how binary data in the source field is encoded, following RFC1341 standards. Use `binary` for raw byte content such as uploaded files, and `base64` for Base64-encoded content passed through text-based systems like JSON APIs. Incorrect encoding causes garbled data or parsing failures.",
      "enum": ["binary", "base64"],
      "default": "binary"
    },
    "profileId": {
      "type": "string",
      "title": "Profile ID",
      "description": "ID of the index profile that defines parser configuration, media type detection rules, and field mapping. The profile determines which parsers are applied and how extracted fields are mapped, for example, `pdf-parser` for PDF-specific processing. Must reference an existing profile. An invalid ID causes stage failure.",
      "reference": "parser"
    },
    "sourceContentType": {
      "type": "string",
      "title": "Default source Content Type",
      "description": "MIME type of the content in the source field, used as a fallback or override when automatic content type detection is ambiguous. For example, set to `application/pdf` to force PDF parsing or `text/html or charset=UTF-8` to ensure correct character encoding. If unset, content type is detected automatically via file extension or magic bytes."
    },
    "inheritFields": {
      "type": "boolean",
      "title": "Inherit Fields",
      "description": "Controls whether child documents generated by parsing inherit field values from the parent document. When `true`, all parent fields such as `source_system` or `import_date` are copied into each child document. When `false`, children contain only fields extracted by the parser. Set to `false` to reduce document size or avoid field conflicts when parent metadata is not needed.",
      "default": true
    },
    "continueProcessing": {
      "type": "boolean",
      "title": "Continue processing",
      "description": "Controls whether the original document continues through the pipeline after this stage or is discarded. When `true`, the current document is passed to the next stage. When `false`, the document is discarded. For example, when parsing PDFs, set to `false` to index only the extracted text and not the source file.",
      "default": false
    }
  },
  "category": "Document Transformation",
  "categoryPriority": 9,
  "unsafe": false
};

export const SchemaParamFields = ({schema}) => {
  const sanitize = str => {
    if (typeof str !== "string") return str;
    return str.replace(/^"(.*)"$/s, "$1").replace(/\\/g, "").replace(/"/g, "'");
  };
  const renderMd = str => {
    const s = sanitize(str);
    const text = (/[.!?]\)*$/).test(s) ? s : `${s}.`;
    return text.split(/(\*\*[^*]+\*\*|_[^_]+_|`[^`]+`)/g).map((part, i) => {
      if (part.startsWith("**")) return <strong key={i}>{part.slice(2, -2)}</strong>;
      if (part.startsWith("_")) return <em key={i}>{part.slice(1, -1)}</em>;
      if (part.startsWith("`")) return <code key={i}>{part.slice(1, -1)}</code>;
      return part;
    });
  };
  const {description, properties = {}, required: requiredProps = []} = schema;
  const visibleProps = useMemo(() => Object.entries(properties).filter(([, prop]) => !prop.hints?.includes("hidden")), [properties]);
  const renderProp = ([name, prop]) => {
    const isRequired = requiredProps.includes(name);
    const hasDefault = prop.default !== undefined;
    const rawDefault = prop.default;
    const hints = prop.hints || [];
    const isComplexDefault = hasDefault && (typeof rawDefault === "object" || typeof rawDefault === "string" && (rawDefault.length > 20 || rawDefault.includes('"')));
    const postBadges = [];
    if (prop.title) {
      postBadges.push(<><span className="text-stone-400 dark:text-stone-500">API property: </span>{name}</>);
    }
    const constraints = [];
    if (prop.minimum !== undefined && prop.maximum !== undefined) {
      constraints.push(`Range: ${prop.minimum} – ${prop.maximum}`);
    } else if (prop.minimum !== undefined) {
      constraints.push(`Min: ${prop.minimum}`);
    } else if (prop.maximum !== undefined) {
      constraints.push(`Max: ${prop.maximum}`);
    }
    if (prop.minLength !== undefined && prop.maxLength !== undefined) {
      constraints.push(`Length: ${prop.minLength} – ${prop.maxLength}`);
    } else if (prop.minLength !== undefined) {
      constraints.push(`Min length: ${prop.minLength}`);
    } else if (prop.maxLength !== undefined) {
      constraints.push(`Max length: ${prop.maxLength}`);
    }
    const fieldProps = {
      key: name,
      body: prop.title || name,
      type: prop.type,
      ...postBadges.length > 0 && ({
        post: postBadges
      }),
      ...isRequired && ({
        required: true
      }),
      ...!isComplexDefault && hasDefault ? {
        default: sanitize(String(rawDefault))
      } : {}
    };
    const isObject = prop.type === "object" && prop.properties;
    const isArrayOfObjects = prop.type === "array" && prop.items?.type === "object" && prop.items.properties;
    return <ParamField {...fieldProps}>
        {prop.description && <p>{renderMd(prop.description)}</p>}

        {prop.enum && <p>
            Allowed values: 
            {prop.enum.map((v, i) => <>{i > 0 && ", "}<code key={i}>{String(v)}</code></>)}
          </p>}

        {constraints.length > 0 && <p className="text-stone-500 dark:text-stone-400 text-sm">
            {constraints.join(" · ")}
          </p>}

        {isComplexDefault && <div className="flex">
            <p>
              <strong>Default:</strong>
            </p>
            <pre className="!my-0">
              <code>
                {JSON.stringify(rawDefault, null, 2)}
              </code>
            </pre>
          </div>}

        {isArrayOfObjects && <Expandable title="item properties">
            <SchemaParamFields schema={{
      properties: prop.items.properties,
      required: prop.items.required
    }} />
          </Expandable>}

        {isObject && <Expandable title="properties">
            <SchemaParamFields schema={{
      properties: prop.properties,
      required: prop.required
    }} />
          </Expandable>}
      </ParamField>;
  };
  return <div>
      {description && <p>{renderMd(description)}</p>}

      {visibleProps.map(renderProp)}
    </div>;
};

export const LwTemplate = ({title = "Key questions to get you started", icon = "sparkles", cta = "Powered by Agent Studio", linkHref = "https://lucidworks.com/demo/?utm_source=docs&utm_medium=referral&utm_campaign=docs_cta_ai"}) => {
  const [isLoaded, setIsLoaded] = useState(false);
  useEffect(() => {
    const timer = setTimeout(() => {
      setIsLoaded(true);
    }, 500);
    return () => clearTimeout(timer);
  }, []);
  return <div className="lw-template-container">
      <Card title={title} icon={icon}>
        {isLoaded && <span dangerouslySetInnerHTML={{
    __html: `<lw-template id="a029c1a9-28be-427e-b0e1-5d918920246a"></lw-template
            >`
  }} />}
        <Link href={linkHref} className="agent-studio-link text-left text-gray-600 gap-2 dark:text-gray-400 text-sm font-medium flex flex-row items-center hover:text-primary dark:hover:text-primary-light group-hover:text-primary group-hover:dark:text-primary-light">Powered by Lucidworks Agent Studio</Link>
      </Card>
    </div>;
};

[localhost link]: http://localhost:3000/docs/5.9/fusion/reference/config-ref/pipeline-stages/index-stages/asynchronous-field-parser-index-stage

[mintlify link]: https://doc.lucidworks.com/docs/5.9/fusion/reference/config-ref/pipeline-stages/index-stages/asynchronous-field-parser-index-stage

The Asynchronous Field Parser index stage processes documents and sends them to the async parsing service to perform the parsing. This stage does not complete any parsing on its own.

<Note>
  This stage is available in Fusion 5.9.11 and later.
</Note>

<LwTemplate />

## Configuration

<Tip>
  When entering configuration values in the UI, use *unescaped* characters, such as `\t` for the tab character. When entering configuration values in the API, use *escaped* characters, such as `\\t` for the tab character.
</Tip>

<SchemaParamFields schema={schema} />