ForHosting KIT · Developer Utilities

Ripple Base58 encoder & decoder

“Hello World” becomes JxErpTiA7PhnBMd in Ripple Base58, the XRP Ledger alphabet that starts r, p, s, h, n and skips 0, O, I and l, so your strings follow the same character order as classic XRP addresses. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Text: Hello World
Calculation mode: Encode

You get

Result: JxErpTiA7PhnBMd
Input: Hello World
Base58: JxErpTiA7PhnBMd
Alphabet name: ripple

A Ripple Base58 encoder turns ordinary UTF-8 text into a compact string that uses the fifty-eight-character alphabet popularized by the XRP Ledger for classic addresses, and a Ripple Base58 decoder reverses that mapping so you get the original text back. The alphabet keeps digits and letters but drops zero, capital O, capital I, and lowercase L—the four glyphs humans confuse most—yet orders those remaining symbols completely differently from Bitcoin Base58 and Flickr Base58, so the same bytes produce a different string.

What Ripple Base58 is and how it differs from Bitcoin Base58

Base58 is a binary-to-text family of encodings that map an arbitrary byte sequence onto a fifty-eight-symbol alphabet. The XRP Ledger popularized one concrete ordering of the remaining symbols after dropping zero, capital O, capital I, and lowercase L: the string begins with r, p, s, h, n and continues through a fixed fifty-eight-character table that is not the Bitcoin order and not the Flickr order. Classic XRP addresses therefore look different from Bitcoin addresses even when both avoid the same four ambiguous glyphs.

Encoding walks the input bytes as a big-endian integer in base two hundred fifty-six, repeatedly divides by fifty-eight, and maps each remainder to the Ripple alphabet; leading zero bytes become leading r characters in the output, because r is the zero digit of this alphabet rather than Bitcoin’s one. Decoding reverses the map: each character becomes a digit zero through fifty-seven, the big integer is rebuilt, and the byte array is recovered with the same leading-r rule.

Because the alphabet has no padding character, length alone does not imply a fixed block size the way Base64 does; round-trips still work as long as both sides agree on the Ripple alphabet and the leading-zero convention. When a character outside the alphabet appears—digit zero, capital O, capital I, lowercase L, punctuation, or whitespace—the decoder must fail loudly.

What you can do with it

Human-safe short codes with XRP alphabet order

Encode short labels under the Ripple alphabet so printed codes avoid 0/O/I/l confusion and match XRP-style character ordering.

Teaching Ripple versus Bitcoin Base58 alphabets

Classrooms encode Hello World under both alphabets, compare strings, then force invalid characters to show strict validation.

FAQ

What alphabet does this Ripple Base58 encoder use?

The Ripple/XRP alphabet: rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz. It excludes 0, O, I, and l, with a different character order from Bitcoin Base58.

How is Ripple Base58 different from Bitcoin Base58?

Both drop 0, O, I, and l, but the remaining fifty-eight characters are ordered differently. The same bytes therefore encode to different strings, and leading zeros map to r under Ripple instead of 1 under Bitcoin.

Does this validate full XRP addresses?

No. It only encodes and decodes raw UTF-8 text under the Ripple Base58 alphabet. It does not check account type prefixes or address checksums.

Is the Ripple Base58 encoder free?

The browser tool is free and runs locally.

Why do some Ripple Base58 strings start with the letter r?

Because r is the zero digit of the Ripple alphabet. Leading zero bytes in your data become leading r characters, where Bitcoin Base58 would write ones, and decoding turns them back into zero bytes.

Related tools

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/enc/base58-ripple

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/enc/base58-ripple \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"Hello World"}'

const res = await fetch("https://api.kit.forhosting.com/enc/base58-ripple", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "text": "Hello World"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/enc/base58-ripple",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "text": "Hello World"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/base58-ripple", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"text":"Hello World"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"text":"Hello World"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/base58-ripple", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "text": "Hello World"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "enc.base58_ripple",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

max_chars 100000

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Technical notes

Choose encode to convert plain text into Ripple Base58, or decode to recover UTF-8 from a Ripple Base58 payload; invalid alphabet characters return a clear invalid_input error instead of silent corruption.

How to call the API and what the response contains

The default mode is encode: UTF-8 bytes of text become a Base58 string under the Ripple alphabet. Send a JSON body with a required string field text (aliases input, value, and data) and an optional mode that is either encode or decode. Mode decode treats text as a Ripple Base58 payload and returns the recovered UTF-8 string. Input length is capped at one hundred thousand characters so a single request cannot exhaust Worker memory on pathological big-integer expansion. On success for encode, the response includes mode, input, result and base58 with the same encoded string, alphabet with the full fifty-eight-character Ripple constant, alphabet_name set to ripple, input_bytes as the UTF-8 byte count, output_length as the encoded character count, and a short English message. On success for decode, the response includes mode, input, result and text with the decoded UTF-8 string, the same alphabet fields, input_length, output_bytes, and a matching message. Failed validation—missing text, non-string text, oversize input, an unknown mode, an invalid Base58 character, or decoded bytes that are not valid UTF-8—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item and zero marginal unit price.

Practical tips, limits, and how this differs from Bitcoin and Flickr Base58

When teaching, encode the same sentence under Ripple, Bitcoin, and Flickr alphabets side by side so learners see why the strings differ even though all three drop the same four ambiguous glyphs. Deliberately include a forbidden character—digit zero, capital O, capital I, or lowercase L—in a decode request to assert that your client handles invalid_input and the error message that names the index and the excluded glyphs. Keep payloads under the published character limit; extremely long strings expand as big integers and are better split or handled offline. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when you fuzz invalid alphabet characters.

Integration use cases

XRP-style fixture round-trips in tests

Generate known Ripple Base58 strings from fixture text and assert decode recovers the same UTF-8 bytes in CI without a crypto dependency.

Technical questions

What happens if I decode a string containing 0, O, I, or l?

The API returns invalid_input, names the bad character and its index, and reminds you that Ripple Base58 excludes those four glyphs. Failed tasks are not charged.

Read the full KIT documentation →

Run — free