---
product: Chilkat
product_version: 11.7.0
language: delphidll
language_label: Delphi DLL
class: HtmlToXml
license: bundle
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/dd_CkHtmlToXmlRef.html
---
# Chilkat HtmlToXml — Delphi DLL — v11.7.0

> Chilkat 11.7.0 · language=delphidll · class=HtmlToXml
> Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0/<lang>/classes/HtmlToXml.md`.
> Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/guide.md`.

## Purpose

**Convert HTML into well-formed XML for structured parsing and searching.**

`Chilkat.HtmlToXml` converts HTML into well-formed XML so the content can be parsed, searched, transformed, or processed programmatically with XML tools. It can accept HTML from strings, files, byte arrays, `BinData`, or `StringBuilder`, and provides options for dropping selected tags, removing common text-formatting tags, controlling non-breaking spaces, choosing the XML charset, and saving the converted XML to a file.

**HTML to XML conversion**

Convert real-world HTML into well-formed XML that can be loaded into `Chilkat.Xml` or other XML processing tools.

**Flexible input sources**

Supply HTML from strings, files, byte arrays, `BinData`, or `StringBuilder` depending on how the content is received or built.

**Drop selected tags**

Remove specific tag types from the output when the application wants a cleaner XML result focused on relevant content.

**Text-formatting cleanup**

Drop common formatting tags when the structure matters more than visual presentation.

**NBSP handling**

Control how non-breaking spaces are represented, converted, removed, or preserved in the XML output.

**Charset and file output**

Choose the XML charset and write the converted XML directly to a file when a persisted result is needed.

**Common pattern:** Load or assign the HTML, set any cleanup options such as dropped tags, text-formatting removal, `Nbsp` behavior, and `XmlCharset`, then call the conversion method and parse the result as XML. Use `HtmlToXml` when structured extraction is needed; use `HtmlToText` when the goal is readable plain text.

For an extended overview, see [HtmlToXml Class Overview](https://www.chilkatsoft.com/htmltoxml_class_overview.asp).

## Object creation, unlocking and error handling

**Create/Dispose**

```pascal
var
myObject: HCkHtmlToXml;

begin
myObject := CkHtmlToXml_Create();

// ...

CkHtmlToXml_Dispose(myObject);
end;
```

`function CkHtmlToXml_Create: HCkHtmlToXml; stdcall;`

Creates an instance of the HCkHtmlToXml object and returns a handle (i.e. a Pointer). The handle is passed in the 1st argument for the functions listed on this page.

`procedure CkHtmlToXml_Dispose(handle: HCkHtmlToXml); stdcall;`

Objects created by calling CkHtmlToXml_Create must be freed by calling this method. A memory leak occurs if a handle is not disposed by calling this function.

Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Delphi DLL.

## Members common to every Chilkat class

Documented once per language in `common-members.md`; listed here so this page is self-contained.

| Property | Signature | Access | Meaning |
|---|---|---|---|
| `DebugLogFilePath` | `procedure CkHtmlToXml_getDebugLogFilePath(objHandle: HCkHtmlToXml; outPropVal: HCkString); stdcall; procedure CkHtmlToXml_putDebugLogFilePath(objHandle: HCkHtmlToXml; newPropVal: PWideChar); stdcall; function CkHtmlToXml__debugLogFilePath(objHandle: HCkHtmlToXml): PWideChar; stdcall;` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. |
| `LastErrorHtml` | `procedure CkHtmlToXml_getLastErrorHtml(objHandle: HCkHtmlToXml; outPropVal: HCkString); stdcall; function CkHtmlToXml__lastErrorHtml(objHandle: HCkHtmlToXml): PWideChar; stdcall;` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `procedure CkHtmlToXml_getLastErrorText(objHandle: HCkHtmlToXml; outPropVal: HCkString); stdcall; function CkHtmlToXml__lastErrorText(objHandle: HCkHtmlToXml): PWideChar; stdcall;` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `procedure CkHtmlToXml_getLastErrorXml(objHandle: HCkHtmlToXml; outPropVal: HCkString); stdcall; function CkHtmlToXml__lastErrorXml(objHandle: HCkHtmlToXml): PWideChar; stdcall;` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `function CkHtmlToXml_getLastMethodSuccess(objHandle: HCkHtmlToXml): wordbool; stdcall; procedure CkHtmlToXml_putLastMethodSuccess(objHandle: HCkHtmlToXml; newPropVal: wordbool); stdcall;` | read/write | Indicates the success or failure of the most recent method call: `True` means success, `False` means failure. |
| `VerboseLogging` | `function CkHtmlToXml_getVerboseLogging(objHandle: HCkHtmlToXml): wordbool; stdcall; procedure CkHtmlToXml_putVerboseLogging(objHandle: HCkHtmlToXml; newPropVal: wordbool); stdcall;` | read/write | If set to `True`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `procedure CkHtmlToXml_getVersion(objHandle: HCkHtmlToXml; outPropVal: HCkString); stdcall; function CkHtmlToXml__version(objHandle: HCkHtmlToXml): PWideChar; stdcall;` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `DropCustomTags` | property, read/write | `function CkHtmlToXml_getDropCustomTags(objHandle: HCkHtmlToXml): wordbool; stdcall; procedure CkHtmlToXml_putDropCustomTags(objHandle: HCkHtmlToXml; newPropVal: wordbool); stdcall;` |
| `Html` | property, read/write | `procedure CkHtmlToXml_getHtml(objHandle: HCkHtmlToXml; outPropVal: HCkString); stdcall; procedure CkHtmlToXml_putHtml(objHandle: HCkHtmlToXml; newPropVal: PWideChar); stdcall; function CkHtmlToXml__html(objHandle: HCkHtmlToXml): PWideChar; stdcall;` |
| `Nbsp` | property, read/write | `function CkHtmlToXml_getNbsp(objHandle: HCkHtmlToXml): Integer; stdcall; procedure CkHtmlToXml_putNbsp(objHandle: HCkHtmlToXml; newPropVal: Integer); stdcall;` |
| `XmlCharset` | property, read/write | `procedure CkHtmlToXml_getXmlCharset(objHandle: HCkHtmlToXml; outPropVal: HCkString); stdcall; procedure CkHtmlToXml_putXmlCharset(objHandle: HCkHtmlToXml; newPropVal: PWideChar); stdcall; function CkHtmlToXml__xmlCharset(objHandle: HCkHtmlToXml): PWideChar; stdcall;` |
| `ConvertFile` | method | `function CkHtmlToXml_ConvertFile(objHandle: HCkHtmlToXml;     inHtmlPath: PWideChar;     destXmlPath: PWideChar): wordbool; stdcall;` |
| `DropTagType` | method | `procedure CkHtmlToXml_DropTagType(objHandle: HCkHtmlToXml;     tagName: PWideChar) stdcall;` |
| `DropTextFormattingTags` | method | `procedure CkHtmlToXml_DropTextFormattingTags(objHandle: HCkHtmlToXml) stdcall;` |
| `SetHtmlBd` | method | `function CkHtmlToXml_SetHtmlBd(objHandle: HCkHtmlToXml;     bd: HCkBinData): wordbool; stdcall;` |
| `SetHtmlFromFile` | method | `function CkHtmlToXml_SetHtmlFromFile(objHandle: HCkHtmlToXml;     filename: PWideChar): wordbool; stdcall;` |
| `SetHtmlSb` | method | `function CkHtmlToXml_SetHtmlSb(objHandle: HCkHtmlToXml;     sb: HCkStringBuilder): wordbool; stdcall;` |
| `ToXml` | method | `function CkHtmlToXml_ToXml(objHandle: HCkHtmlToXml;     outStr: HCkString): wordbool; stdcall; function CkHtmlToXml__toXml(objHandle: HCkHtmlToXml): PWideChar; stdcall;` |
| `ToXmlSb` | method | `function CkHtmlToXml_ToXmlSb(objHandle: HCkHtmlToXml;     sb: HCkStringBuilder): wordbool; stdcall;` |
| `UndropTagType` | method | `procedure CkHtmlToXml_UndropTagType(objHandle: HCkHtmlToXml;     tagName: PWideChar) stdcall;` |
| `UndropTextFormattingTags` | method | `procedure CkHtmlToXml_UndropTextFormattingTags(objHandle: HCkHtmlToXml) stdcall;` |
| `Xml` | method | `function CkHtmlToXml_Xml(objHandle: HCkHtmlToXml;     outStr: HCkString): wordbool; stdcall; function CkHtmlToXml__xml(objHandle: HCkHtmlToXml): PWideChar; stdcall;` |

Deprecated members are listed at the end of this file with their replacements; do not use them in new code.

## Properties

### HtmlToXml.DropCustomTags

`Chilkat 11.7.0 · delphidll · HtmlToXml · DropCustomTags · property · read/write`

```pascal
function CkHtmlToXml_getDropCustomTags(objHandle: HCkHtmlToXml): wordbool; stdcall;
procedure CkHtmlToXml_putDropCustomTags(objHandle: HCkHtmlToXml; newPropVal: wordbool); stdcall;
```

Controls whether tags that Chilkat does not recognize as standard HTML elements are omitted from the generated XML.

**When to use:** Set this property to `True` when custom or application-specific tags would add noise to the XML structure. Leave it `False` when those tags are meaningful to the application and should remain represented in the converted output.

### HtmlToXml.Html

`Chilkat 11.7.0 · delphidll · HtmlToXml · Html · property · read/write`

```pascal
procedure CkHtmlToXml_getHtml(objHandle: HCkHtmlToXml; outPropVal: HCkString); stdcall;
procedure CkHtmlToXml_putHtml(objHandle: HCkHtmlToXml; newPropVal: PWideChar); stdcall;
function CkHtmlToXml__html(objHandle: HCkHtmlToXml): PWideChar; stdcall;
```

The HTML source to be converted. Set this property to an HTML string, configure any conversion options, and then call `ToXml`, `Xml`, or `ToXmlSb`.

Assigning this property replaces the current in-memory HTML source. For file-to-file conversion, use `ConvertFile`. To load HTML from a file, `BinData`, or `StringBuilder`, use the corresponding `SetHtml*` method.

**HTML input does not need to already be valid XML.** The converter is intended for real-world HTML and repairs markup as needed to produce a well-formed XML document. Chilkat examples show malformed HTML being normalized and ordinary text represented in `<text>` elements to simplify programmatic extraction.

### HtmlToXml.Nbsp

`Chilkat 11.7.0 · delphidll · HtmlToXml · Nbsp · property · read/write`

```pascal
function CkHtmlToXml_getNbsp(objHandle: HCkHtmlToXml): Integer; stdcall;
procedure CkHtmlToXml_putNbsp(objHandle: HCkHtmlToXml; newPropVal: Integer); stdcall;
```

Controls how HTML non-breaking-space entities are handled during conversion. The default value is `0`.

| Value | Behavior for `&nbsp;` |
| :--- | :--- |
| `0` | Convert to a normal space character (U+0020). |
| `1` | Convert to the numeric character reference `&#160;` (U+00A0). |
| `2` | Drop the non-breaking-space entity. |
| `3` | Leave the `&nbsp;` entity unconverted by this option. |

This setting applies specifically to the HTML entity `&nbsp;`; it does not define general whitespace normalization.

### HtmlToXml.XmlCharset

`Chilkat 11.7.0 · delphidll · HtmlToXml · XmlCharset · property · read/write`

```pascal
procedure CkHtmlToXml_getXmlCharset(objHandle: HCkHtmlToXml; outPropVal: HCkString); stdcall;
procedure CkHtmlToXml_putXmlCharset(objHandle: HCkHtmlToXml; newPropVal: PWideChar); stdcall;
function CkHtmlToXml__xmlCharset(objHandle: HCkHtmlToXml): PWideChar; stdcall;
```

Specifies the character encoding to identify for the generated XML, such as `utf-8` or `iso-8859-1`. If this property is empty, Chilkat uses the character encoding of the HTML input. Otherwise, the converted XML uses the specified charset.

**String versus file output:** A string returned by `ToXml` or `Xml` is a string in the programming language's native string representation, while the XML declaration reflects `XmlCharset`. When writing that string to a file, use the same charset so the file bytes agree with the XML declaration. `ConvertFile` performs the file conversion directly.

## Methods

### HtmlToXml.ConvertFile

`Chilkat 11.7.0 · delphidll · HtmlToXml · ConvertFile · method`

```pascal
function CkHtmlToXml_ConvertFile(objHandle: HCkHtmlToXml;
    inHtmlPath: PWideChar;
    destXmlPath: PWideChar): wordbool; stdcall;
```

Converts the HTML file at `inHtmlPath` to a well-formed XML file at `destXmlPath`. The output encoding is controlled by `XmlCharset`; if `XmlCharset` is empty, Chilkat uses the HTML source encoding.

Returns `True` on success and `False` on failure.

**Conversion behavior:** The input is parsed as HTML rather than XML. Chilkat can normalize malformed or incomplete HTML markup as part of producing a well-formed XML document suitable for subsequent parsing and data extraction.

Returns True for success, False for failure.

### HtmlToXml.DropTagType

`Chilkat 11.7.0 · delphidll · HtmlToXml · DropTagType · method`

```pascal
procedure CkHtmlToXml_DropTagType(objHandle: HCkHtmlToXml;
    tagName: PWideChar) stdcall;
```

Marks the specified HTML tag type to be dropped from the generated XML. To drop multiple tag types, call this method once for each tag name.

The setting remains in effect for subsequent conversions performed by this `HtmlToXml` object. Use `UndropTagType` to reverse the setting for a particular tag type.

### HtmlToXml.DropTextFormattingTags

`Chilkat 11.7.0 · delphidll · HtmlToXml · DropTextFormattingTags · method`

```pascal
procedure CkHtmlToXml_DropTextFormattingTags(objHandle: HCkHtmlToXml) stdcall;
```

Configures the converter to drop common text-formatting tags from the generated XML. The affected tag names are:

`b`, `font`, `i`, `u`, `br`, `center`, `em`, `strong`, `big`, `tt`, `s`, `small`, `strike`, `sub`, and `sup`.

This is useful when the formatting markup is not relevant to later XML parsing and the application wants a simpler structural representation. Call `UndropTextFormattingTags` to keep these tags instead.

### HtmlToXml.SetHtmlBd

`Chilkat 11.7.0 · delphidll · HtmlToXml · SetHtmlBd · method · since 9.5.0.77`

```pascal
function CkHtmlToXml_SetHtmlBd(objHandle: HCkHtmlToXml;
    bd: HCkBinData): wordbool; stdcall;
```

Replaces the current HTML source with the complete contents of `bd`.

The data is copied from the supplied `BinData` object and becomes the input for a later call to `ToXml`, `Xml`, or `ToXmlSb`. Returns `True` on success and `False` on failure.

Returns True for success, False for failure.

### HtmlToXml.SetHtmlFromFile

`Chilkat 11.7.0 · delphidll · HtmlToXml · SetHtmlFromFile · method`

```pascal
function CkHtmlToXml_SetHtmlFromFile(objHandle: HCkHtmlToXml;
    filename: PWideChar): wordbool; stdcall;
```

Loads HTML from `filename` and replaces the current `Html` input with the file contents.

Returns `True` on success and `False` if the file cannot be read or the HTML input cannot be loaded. Call `ToXml`, `Xml`, or `ToXmlSb` afterward to perform the conversion.

Returns True for success, False for failure.

### HtmlToXml.SetHtmlSb

`Chilkat 11.7.0 · delphidll · HtmlToXml · SetHtmlSb · method · since 9.5.0.97`

```pascal
function CkHtmlToXml_SetHtmlSb(objHandle: HCkHtmlToXml;
    sb: HCkStringBuilder): wordbool; stdcall;
```

Replaces the current HTML source with the complete contents of `sb`.

The text is copied from the supplied `StringBuilder` and becomes the input for a later call to `ToXml`, `Xml`, or `ToXmlSb`. Returns `True` on success and `False` on failure.

Returns True for success, False for failure.

### HtmlToXml.ToXml

`Chilkat 11.7.0 · delphidll · HtmlToXml · ToXml · method`

```pascal
function CkHtmlToXml_ToXml(objHandle: HCkHtmlToXml;
    outStr: HCkString): wordbool; stdcall;
function CkHtmlToXml__toXml(objHandle: HCkHtmlToXml): PWideChar; stdcall;
```

Converts the current `Html` input to well-formed XML and returns the XML string. The generated XML uses the conversion settings currently configured on this object, including `DropCustomTags`, dropped tag types, `Nbsp`, and `XmlCharset`.

**HTML normalization:** The input is parsed as HTML, so it does not need to already be well-formed XML. Chilkat can repair incomplete or malformed markup. The generated document is wrapped in a root element, and Chilkat represents ordinary text content in `<text>` elements to make extraction with XML tools straightforward.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

### HtmlToXml.ToXmlSb

`Chilkat 11.7.0 · delphidll · HtmlToXml · ToXmlSb · method · since 9.5.0.77`

```pascal
function CkHtmlToXml_ToXmlSb(objHandle: HCkHtmlToXml;
    sb: HCkStringBuilder): wordbool; stdcall;
```

Converts the current `Html` input to well-formed XML and appends the generated XML to `sb`.

Returns `True` on success and `False` on failure. Because the result is appended, clear the destination `StringBuilder` first when replacement rather than concatenation is desired.

Returns True for success, False for failure.

### HtmlToXml.UndropTagType

`Chilkat 11.7.0 · delphidll · HtmlToXml · UndropTagType · method`

```pascal
procedure CkHtmlToXml_UndropTagType(objHandle: HCkHtmlToXml;
    tagName: PWideChar) stdcall;
```

Reverses a previous `DropTagType` setting for the specified tag name so that tag type is no longer intentionally dropped from subsequent XML output.

This affects only the named tag type. Other tag types previously configured to be dropped remain unchanged.

### HtmlToXml.UndropTextFormattingTags

`Chilkat 11.7.0 · delphidll · HtmlToXml · UndropTextFormattingTags · method`

```pascal
procedure CkHtmlToXml_UndropTextFormattingTags(objHandle: HCkHtmlToXml) stdcall;
```

Configures the converter to retain the common text-formatting tags that are otherwise dropped by default:

`b`, `font`, `i`, `u`, `br`, `center`, `em`, `strong`, `big`, `tt`, `s`, `small`, `strike`, `sub`, and `sup`.

Call `DropTextFormattingTags` to return to dropping these formatting tags.

### HtmlToXml.Xml

`Chilkat 11.7.0 · delphidll · HtmlToXml · Xml · method`

```pascal
function CkHtmlToXml_Xml(objHandle: HCkHtmlToXml;
    outStr: HCkString): wordbool; stdcall;
function CkHtmlToXml__xml(objHandle: HCkHtmlToXml): PWideChar; stdcall;
```

Equivalent to `ToXml`. Converts the current `Html` input to well-formed XML and returns the XML string using the object's current conversion settings.

This method is provided as an alternate name for `ToXml`; it does not perform a different conversion.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

## Deprecated members — do not use in new code

| Member | Kind | Deprecated in | Use instead |
|---|---|---|---|
| `ReadFile` | method | before 11.6.1 | — |
| `ReadFileToString` | method | before 11.6.1 | — |
| `SetHtmlBytes` | method | before 11.6.1 | — |
| `WriteFile` | method | before 11.6.1 | — |
| `WriteStringToFile` | method | before 11.6.1 | — |

## Related classes

[`BinData`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/BinData.md), [`StringBuilder`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/StringBuilder.md)

