xrpl-dev-portal/content/tutorials/get-started/get-started-with-python-sdk.md

html, funnel, doc_type, category, subcategory, blurb, cta_text

html	funnel	doc_type	category	subcategory	blurb	cta_text
get-started-python.html	Build	Tutorials	Get Started	Get Started Using Python	Build a simple Python app that interacts with the XRP Ledger.	Build Apps

Get started using Python

This tutorial walks you through the basics of building an XRP Ledger-connected application using xrpl-py, a Python library that makes it easy to integrate XRP Ledger functionality into your apps.

Learning goals

In this tutorial, you'll learn:

• How to set up your environment for Python development. See .
• The basic building blocks of XRP Ledger-based applications.
• How to generate keys.
• How to connect to the XRP Ledger.
• How to submit a transaction, including preparing and signing it.
• How to put these steps together to create a simple app that submits a transaction to the XRP Ledger Testnet.

Requirements

For information about setting up your environment for Python development, see .

Start building

{% set n = cycler(* range(1,99)) %}

When you're working with the XRP Ledger, there are a few things you'll need to manage with your app or integration, whether you're adding XRP into your [wallet](xref: wallets.md), integrating with the [decentralized exchange](xref: decentralized-exchange.md), or issuing and managing tokens. This tutorial walks you through the patterns common to all of these use cases and provides sample code for implementing them.

Here are the basic steps you'll need to cover for almost any XRP Ledger project:

1. Generate keys.
2. Connect to the XRP Ledger.
3. Query the XRP Ledger.
4. Submit a transaction.
5. Verify results.

{{n.next()}}. Generate keys

You need keys to sign transactions that you submit to the XRP Ledger.

For testing and development purposes, you can get keys (and XRP balances) from XRP Faucets.

Otherwise, you should take care to store your keys and set up a secure signing method.

Generate keypairs (xrpl-py)

# Generate private and public keys
# to manage your XRP Ledger account
def generateKeys():
    seed = keypairs.generate_seed()
    public, private = keypairs.derive_keypair(seed)
    CLASSIC_ACCOUNT = keypairs.derive_classic_address(public)
    print("Here's the public key: ", public)
    print("Here's the private key: ", private)

Generate wallet (xrpl-py)

# Create an XRP Ledger wallet
# And create an x-address for the address
def createWallet():
    wallet = Wallet.generate_seed_and_wallet()
    address = wallet.classic_address
    xaddress = addresscodec.classic_address_to_xaddress(
                classic_address, tag, True
            )
    print("Classic address:", address)
    print("X-address:", xaddress)

{{n.next()}}. Connect

To make queries that you can use in your app and submit transactions, you need to establish a connection to the XRP Ledger. There are a few ways to do this. The following sections describe each option in more detail.

Warning: Never use publicly available servers to sign transactions. For more information about security and signing, see [](xref: set-up-secure-signing.md).

Caution: Ripple provides the Testnet and Devnet for testing purposes only, and sometimes resets the state of these test networks along with all balances. As a precaution, Ripple recommends not using the same addresses on Testnet/Devnet and Mainnet.

If you only want to explore the XRP Ledger, you can use the Ledger Explorer to see the Ledger progress in real-time and dig into specific accounts or transactions.

# Define the URL of the server you want to use
JSON_RPC_URL = "http://s1.ripple.com:51234/"

{{n.next()}}. Query

Before you submit a transaction to the XRP Ledger, you should query it to check your account status and balances to make sure that the transaction will succeed.

# Look up information about your account
def getAcctInfo():
    client = JsonRpcClient(JSON_RPC_URL)
    acct_info = AccountInfo(
        account=address,
        ledger_index="current",
        queue=True,
        strict=True,
    )
    response = client.request(acct_info)
    print("response.status: ", response.status)
    print("response.result: ", response.result)
    print("response.id: ", response.id)
    print("response.type: ", response.type)

{{n.next()}}. Submit transaction

Submitting a transaction to the XRP inolves three distinct steps:

• Preparing the transaction.
• Signing the transaction.
• Submitting the transaction to an XRP Ledger node.

With xrpl-py, you can combine the these steps by using the tx.to_dict function and the Sign model.

 # Prepare the tx by formatting it into
# the shape expected by the XRP Ledger
# and signing it
def prepareSignSubmitTx():
    CLASSIC_ACCOUNT.next_sequence_num = get_next_valid_seq_number(CLASSIC_ACCOUNT, JSON_RPC_CLIENT)
    tx = Transaction(
        account=_ACCOUNT,
        fee=_FEE,
        sequence=CLASSIC_ACCOUNT.next_seuqnece_num + 10,
        transaction_type=TransactionType.
    )
    value = tx.to_dict()["payment_trannsaction"]
    signed_tx = Sign(
        transaction=value,
        seed=_SEED,
        seed_hex=_SEED_HEX,
    )
    print("Signed transaction: ", signed_tx)
    payment_transaction = Payment.from_dict(value)
    response = send_reliable_submission(
        payment_transaction, CLASSIC_ACCOUNT, JSON_RPC_URL
        )
    print("response.result.validated: ", response["validated"])
    print("response.result.meta: ", response.result["meta"]["TransactionResult"], "tesSUCCESS")

{{n.next()}}. Verify results

To ensure that your transaction has succeeded in a validated ledger, which means that the results are final, you can add simple logic to your submit function:

if response.result["meta"]["TransactionResult"] != "tesSUCCESS":
    print("Transaction not yet validated")
else:
    print("Validated!")  

{{n.next()}}. Putting it all together

Using these building blocks, we can create a simple app that:

1. Generates a wallet.
2. Connects to the XRP Ledger.
3. Looks up information about your account.
4. Sends XRP from one account to another.
5. Verifies the transaction in a validated ledger.

{% include '_code-samples/xrpl-py/simple-python-app.py' %}

Next steps

<<TODO: Flesh out these steps>>

Try using xrpl-py to:

• Set Account Flags
• Issue a token on the Devnet
• Set up an escrow