> ## 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.

# Apache Tika Server

> Parser stage configuration specifications

export const schema = {
  "type": "object",
  "title": "Apache Tika Server (Deprecated) ",
  "description": "Parses documents by delegating to an external Apache Tika Server instance via HTTP, reducing memory requirements on connector pods since parsing happens externally. Deprecated: use the Apache Tika Container Parser instead, which provides better integration with async-parsing infrastructure and improved isolation.",
  "required": ["type"],
  "properties": {
    "id": {
      "type": "string",
      "title": "Parser ID",
      "default": "fadea556-ed79-47ae-9343-cdf9676dbd3c"
    },
    "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.",
      "maxLength": 255
    },
    "enabled": {
      "type": "boolean",
      "title": "Enable this Parser Stage",
      "default": true,
      "description": "Controls whether this parser stage is active and available for use. When `false`, the stage is completely inactive regardless of other settings. When `true`, the stage runs according to its other configuration options."
    },
    "mediaTypes": {
      "type": "array",
      "title": "Media Types to match",
      "description": "Specifies the media types this parser stage handles. Documents with a matching media type are routed to this stage for parsing. See `inheritMediaTypes` to combine this list with the stage's built-in defaults.",
      "items": {
        "type": "string",
        "pattern": "^[^\\/]+\\/[^\\/]+$",
        "format": "rfc2646"
      }
    },
    "inheritMediaTypes": {
      "type": "boolean",
      "title": "Match default media types in this Parser Stage",
      "description": "Controls whether this stage combines its built-in default media types with those in `mediaTypes`. When `true`, both lists are merged. When `false`, only the `mediaTypes` list is used and must contain at least one entry. Set to `false` to override the default media types entirely.",
      "default": true
    },
    "ignoredMediaTypes": {
      "type": "array",
      "title": "Media Types to ignore",
      "description": "Specifies media types this parser stage excludes from processing. Documents matching an ignored media type are skipped even if they match `mediaTypes`. Use this to carve out exceptions from a broadly matched media type set.",
      "items": {
        "type": "string",
        "pattern": "^[^\\/]+\\/[^\\/]+$",
        "format": "rfc2646"
      }
    },
    "pathPatterns": {
      "type": "array",
      "title": "File names to parse",
      "description": "Restricts this parser stage to files whose names match the specified pattern. Use forward slashes (`/`) to join archive names with entry names when matching files inside archives. If no pattern is specified, the stage applies to all matching media types.",
      "items": {
        "type": "object",
        "properties": {
          "syntax": {
            "type": "string",
            "title": "Pattern type",
            "description": "glob uses bash shell-style wildcards and regex uses Java (PCRE-style) regex.",
            "enum": ["glob", "regex"],
            "default": "glob"
          },
          "pattern": {
            "type": "string",
            "title": "File name or pattern",
            "description": "glob examples are \"z.txt\" or \"*.md\" or \"/a/*/b/f.txt\". regex examples are \"z.txt$\" or \".*\\.txt$\" or \"^/a/[^\\/]*/b/f.txt$\"."
          }
        }
      }
    },
    "errorHandling": {
      "type": "string",
      "title": "Error Handling",
      "enum": ["ignore", "log", "fail", "mark"],
      "default": "mark"
    },
    "outputFieldPrefix": {
      "type": "string",
      "title": "Prefix parsed fields with",
      "description": "Sets a string prefix applied to all fields extracted by this parser, useful for namespacing or avoiding field name collisions. For example, `tika_` produces fields like `tika_title` and `tika_author`. Leave empty to apply no prefix.",
      "maxLength": 20,
      "pattern": "^$|^[A-Za-z_][A-Za-z0-9_\\-\\.]+$"
    },
    "customTikaServerEndpoints": {
      "type": "array",
      "title": "Custom tika server endpoints",
      "description": "Specifies custom Tika Server endpoint URLs to use instead of Fusion's default `http://tikaserver` service. Provide one or more URLs for load balancing or when using external Tika Server instances, such as `http://custom-tika:9998`. If not set, the default internal Tika service is used.",
      "items": {
        "type": "string",
        "minLength": 1
      }
    },
    "excludeContentTypes": {
      "type": "array",
      "title": "Content types to exclude",
      "description": "Specifies MIME content types this stage excludes from parsing. Documents matching these types are skipped even if they otherwise match `mediaTypes`. Use this to block specific formats within a broad media type pattern.",
      "items": {
        "type": "string",
        "minLength": 1
      }
    },
    "addOriginalContent": {
      "type": "boolean",
      "title": "Add original document content (raw bytes)",
      "default": false
    },
    "addFailedDocs": {
      "type": "boolean",
      "title": "Add failed documents",
      "default": false
    },
    "includeImages": {
      "type": "boolean",
      "title": "Include images",
      "default": false
    },
    "contentEncoding": {
      "type": "string",
      "title": "Content transport encoding of the content (per RFC1341)",
      "enum": ["binary", "base64"],
      "default": "binary"
    },
    "maxBytesReturned": {
      "type": "integer",
      "title": "Max bytes returned",
      "description": "Sets the maximum bytes of extracted text the Tika Server parser returns. Content beyond this limit is truncated. Prevents memory exhaustion from extremely large documents or extraction outputs.",
      "default": 100000000
    },
    "maxMetadataFieldBytes": {
      "type": "integer",
      "title": "Max metadata field bytes",
      "description": "Sets the maximum bytes allowed for any individual metadata field value extracted by Tika. Field values exceeding this limit are truncated. Prevents excessively large metadata values from consuming memory or causing indexing issues.",
      "default": 30000
    },
    "maxEmbeddedDocuments": {
      "type": "integer",
      "title": "Max embedded documents",
      "description": "Sets the maximum number of embedded documents to extract and parse from container files. Documents beyond this limit are ignored. Set to `0` to skip all embedded document parsing.",
      "default": -1
    },
    "parseTimeoutMs": {
      "type": "integer",
      "title": "Parse timeout (ms)",
      "description": "Sets the maximum execution time in milliseconds before the Tika Server request times out. Prevents pipeline blocking from slow parsing operations. Increase this value when parsing large or complex documents that require more processing time.",
      "default": 15000
    },
    "cleanNonAsciiText": {
      "type": "boolean",
      "title": "Remove all non-ascii text",
      "default": false
    },
    "tikaServerClientMaxRetries": {
      "type": "integer",
      "title": "Tika server client max retries",
      "description": "Sets the maximum number of retry attempts when a Tika Server request fails due to network errors or server unavailability. Set to `-1` for unlimited retries (use with caution) or `0` to fail immediately without retrying.",
      "default": 2
    },
    "tikaServerClientBackOffDelayMs": {
      "type": "integer",
      "title": "Tika server client backoff delay (ms)",
      "description": "Sets the initial delay in milliseconds between retry attempts when Tika Server requests fail. This delay grows exponentially with each retry, multiplied by `tikaServerClientBackOffDelayFactor`, up to `tikaServerClientBackOffMaxDelayMs`. Exponential backoff prevents overwhelming the server during recovery from transient failures.",
      "default": 1000
    },
    "tikaServerClientBackOffMaxDelayMs": {
      "type": "integer",
      "title": "Tika server client max backoff delay (ms)",
      "description": "Sets the maximum delay in milliseconds between retry attempts, capping the exponential backoff growth. Prevents excessively long waits between retries while still allowing backoff to slow retries during extended outages.",
      "default": 60000
    },
    "tikaServerClientBackOffDelayFactor": {
      "type": "number",
      "title": "Tika server client max backoff delay factor",
      "description": "Sets the multiplication factor for exponential backoff between retry attempts. Values greater than `1.0` implement exponential backoff. `1.0` means constant delay. Higher factors reach maximum delay faster, providing more recovery time for the server.",
      "default": 2
    },
    "tikaServerClientRetryMaxDurationMs": {
      "type": "integer",
      "title": "Tika server client retry max duration (ms)",
      "description": "Sets the maximum total time in milliseconds spent on all retry attempts before failing the document. Prevents indefinite retry loops and ensures documents fail or succeed within a predictable timeframe.",
      "default": 120000
    },
    "type": {
      "type": "string",
      "enum": ["tikaserver"],
      "default": "tikaserver"
    }
  },
  "additionalProperties": false,
  "category": "Other",
  "categoryPriority": 1,
  "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/lucidworks-search/09-developer-documentation/config-specs/parsers/apache-tika-server

[mintlify link]: https://doc.lucidworks.com/docs/lucidworks-search/09-developer-documentation/config-specs/parsers/apache-tika-server

[old doc.lw link]: https://doc.lucidworks.com/managed-fusion/5.9/cy28u3

<Note>
  **Important**
  This stage is deprecated in Fusion 5.8.x and removed in Fusion 5.9.12.
  Use the [Apache Tika Container parser](/docs/lucidworks-search/09-developer-documentation/config-specs/parsers/apache-tika-container) instead.
</Note>

<LwTemplate />

Apache Tika Server is a versatile parser that supports parsing many document formats.

This stage is not compatible with asynchronous Tika parsing.

<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} />