Décodez du Base64 sans rien envoyer.

import base64

# Base64 string -> text
encoded = "SGVsbG8sIHdvcmxkIQ=="
text = base64.b64decode(encoded).decode("utf-8")
print(text)                      # Hello, world!

# Reject anything that is not valid Base64 instead of silently skipping it
base64.b64decode(encoded, validate=True)

# URL-safe alphabet (RFC 4648 section 5): "-" and "_" instead of "+" and "/"
base64.urlsafe_b64decode("SGVsbG8_d29ybGQtMQ==")

# Unpadded input (JWTs, URL parameters) raises binascii.Error -- pad it first
def b64decode_any(s: str) -> bytes:
    s = s.replace("-", "+").replace("_", "/")
    return base64.b64decode(s + "=" * (-len(s) % 4))

# Base64 -> image file on disk
with open("logo.png", "wb") as f:
    f.write(base64.b64decode(image_b64))

# Decode every line of a file separately
with open("encoded.txt") as f:
    for line in f:
        print(base64.b64decode(line.strip()).decode("utf-8"))

// ── Browser ──────────────────────────────────────────────
// Quick and dirty: correct only for pure ASCII
atob("SGVsbG8sIHdvcmxkIQ==");            // "Hello, world!"

// Correct for any UTF-8 payload
function base64Decode(b64) {
  const bin = atob(b64);
  const bytes = Uint8Array.from(bin, (ch) => ch.charCodeAt(0));
  return new TextDecoder().decode(bytes);
}
base64Decode("SGVsbMO2LCB3w7ZybGQh");    // "Hellö, wörld!"

// Encoding back again
function base64Encode(str) {
  const bytes = new TextEncoder().encode(str);
  return btoa(String.fromCharCode(...bytes));
}

// URL-safe -> standard before decoding
const std = urlSafe.replace(/-/g, "+").replace(/_/g, "/");

// ── Node.js ──────────────────────────────────────────────
Buffer.from("SGVsbG8sIHdvcmxkIQ==", "base64").toString("utf8");
Buffer.from(token, "base64url").toString("utf8");   // Node 16+
Buffer.from("Hello, world!").toString("base64");

# Decode a string
echo "SGVsbG8sIHdvcmxkIQ==" | base64 --decode

# printf avoids the trailing newline echo adds
printf '%s' "SGVsbG8sIHdvcmxkIQ==" | base64 -d

# Decode a file into a binary file
base64 -d encoded.txt > decoded.png

# -i ignores line wrapping and other non-alphabet characters
base64 -di encoded.txt > decoded.bin

# Older macOS releases only know a capital -D (--decode works on all of them)
base64 -D <<< "SGVsbG8sIHdvcmxkIQ=="

# Portable everywhere OpenSSL exists
echo "SGVsbG8sIHdvcmxkIQ==" | openssl base64 -d

# Encode, wrapping at 76 columns like MIME (-w 0 disables wrapping)
base64 -w 0 photo.jpg > photo.b64

# Decode a JWT payload (URL-safe, unpadded) with jq
cut -d. -f2 <<< "$JWT" | tr '_-' '/+' | base64 -d 2>/dev/null | jq .

<?php
$text = base64_decode('SGVsbG8sIHdvcmxkIQ==');

// Strict mode: false on invalid input
$text = base64_decode($encoded, true);
if ($text === false) {
    throw new InvalidArgumentException('Not valid Base64');
}

// URL-safe decode with padding repaired
function base64UrlDecode(string $s): string {
    $s = strtr($s, '-_', '+/');
    return base64_decode($s . str_repeat('=', (4 - strlen($s) % 4) % 4));
}

// Base64 -> image file
file_put_contents('logo.png', base64_decode($imageB64));

// Encode a file as a data: URI for inline CSS or HTML
$uri = 'data:image/png;base64,' . base64_encode(file_get_contents('logo.png'));

import java.nio.charset.StandardCharsets;
import java.util.Base64;

byte[] bytes = Base64.getDecoder().decode("SGVsbG8sIHdvcmxkIQ==");
String text = new String(bytes, StandardCharsets.UTF_8);

// URL-safe alphabet
Base64.getUrlDecoder().decode(token);

// MIME decoder: ignores line breaks and other stray characters
Base64.getMimeDecoder().decode(wrappedInput);

// Encode
String encoded = Base64.getEncoder()
    .encodeToString("Hello, world!".getBytes(StandardCharsets.UTF_8));

// Base64 -> file
java.nio.file.Files.write(java.nio.file.Path.of("logo.png"),
    Base64.getDecoder().decode(imageB64));

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	data, err := base64.StdEncoding.DecodeString("SGVsbG8sIHdvcmxkIQ==")
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data)) // Hello, world!

	// URL-safe, no padding -- the JWT flavour
	base64.RawURLEncoding.DecodeString("SGVsbG8sIHdvcmxkIQ")

	// Encode
	fmt.Println(base64.StdEncoding.EncodeToString([]byte("Hello, world!")))
}

using System;
using System.Text;

byte[] bytes = Convert.FromBase64String("SGVsbG8sIHdvcmxkIQ==");
string text = Encoding.UTF8.GetString(bytes);

// Non-throwing variant
Span<byte> buffer = new byte[input.Length];
if (Convert.TryFromBase64String(input, buffer, out int written))
{
    text = Encoding.UTF8.GetString(buffer[..written]);
}

// URL-safe input
string std = input.Replace('-', '+').Replace('_', '/')
                  .PadRight(input.Length + (4 - input.Length % 4) % 4, '=');

// Encode
Convert.ToBase64String(Encoding.UTF8.GetBytes("Hello, world!"));

# ── PowerShell (Windows, macOS, Linux) ──────────────────
$b64 = "SGVsbG8sIHdvcmxkIQ=="
[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($b64))   # Hello, world!

# Base64 file -> binary file (.NET needs an absolute path)
$bytes = [Convert]::FromBase64String((Get-Content encoded.txt -Raw))
[IO.File]::WriteAllBytes("$PWD\decoded.png", $bytes)

# Encode
[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("Hello, world!"))

# ── Command Prompt (cmd.exe) ─────────────────────────────
certutil -decode encoded.txt decoded.png
# certutil -encode wraps its output in BEGIN/END CERTIFICATE lines
certutil -encode photo.jpg photo.b64

# ── Ruby ─────────────────────────────────────────────────
require "base64"
Base64.decode64("SGVsbG8sIHdvcmxkIQ==")        # forgiving
Base64.strict_decode64("SGVsbG8sIHdvcmxkIQ==") # raises on stray characters
Base64.urlsafe_decode64(token)

# ── SQL ──────────────────────────────────────────────────
# MySQL 5.6+   SELECT FROM_BASE64('SGVsbG8sIHdvcmxkIQ==');
# PostgreSQL   SELECT convert_from(decode('SGVsbG8=', 'base64'), 'UTF8');
# SQL Server   SELECT CAST('' AS xml).value('xs:base64Binary("SGVsbG8=")', 'varbinary(max)');
# BigQuery     SELECT SAFE_CONVERT_BYTES_TO_STRING(FROM_BASE64('SGVsbG8='));