Here is a quick tutorial on how to generate API Key, Secret, and Passphrase to Polymarket.com. This way you can start trading using Python and skip the web interface.

keys.env

The first step is to create an environment file. You only want to populate the PK value. You do not know the other 3 variables yet so just comment them out. You can find this private key by logging in to your Polymarket.com account. Clicking on ‘Cash’, 3 dots, and finally Export Private Key.

#remove the '0x'
PK = "PRIVATE KEY EXPORTED FROM POLYMARKET.COM"

#these are generated through get_api_key.py do not specify these until you run the script with your private key
#API Key: xxxxxxxx-xxxx-xxxxx-xxxx-xxxxxxxxxxxx
#Secret: Lxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
#Passphrase: dxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxe9

generate_api_key.py

import os
from py_clob_client.client import ClobClient
from dotenv import load_dotenv

# Load the environment variables from the specified .env file
load_dotenv('keys.env')

def main():
    host = "https://clob.polymarket.com"
    key = os.getenv("PK")
    chain_id = 137  # Polygon Mainnet chain ID

    # Ensure the private key is loaded correctly
    if not key:
        raise ValueError("Private key not found. Please set PK in the environment variables.")

    # Initialize the client with your private key
    client = ClobClient(host, key=key, chain_id=chain_id)

    # Create or derive API credentials (this is where the API key, secret, and passphrase are generated)
    try:
        api_creds = client.create_or_derive_api_creds()
        print("API Key:", api_creds.api_key)
        print("Secret:", api_creds.api_secret)
        print("Passphrase:", api_creds.api_passphrase)

        # You should now save these securely (e.g., store them in your .env file)
    except Exception as e:
        print("Error creating or deriving API credentials:", e)

if __name__ == "__main__":
    main()

Recently I started exploring arbitrage opportunities in the Polymarket.com world. I quickly realized I would need faster access to the data. So I wrote some Python programs to access the platform for data analytics. The documents for doing this are located in the Polymarket docs. Here’s how it works.

Install py-clob-client

pip install py-clob-client<br><br>

Coinbase Wallet

To perform this first block of code you need a Coinbase wallet. Once you have it setup you need to export your private key.

from py_clob_client.client import ClobClient

host = "https://clob.polymarket.com"
private_key = "YOUR_PRIVATE_KEY_GOES_HERE"
chain_id = 137  # Polygon Mainnet

# Initialize the client with private key
client = ClobClient(host, key=private_key, chain_id=chain_id)

api_key_data = client.create_api_key()

print(api_key_data)

Creating keys.py

We can take this outputted data and create our keys.py which will hold our keys.For some reason, the api_passphrase and rename it api_key while commenting out the original api_key. I left the api_secret and original api_passphrase. Now that I have my keys.py I can reference it in my main code

Extracting all of the data

import csv
import json
from py_clob_client.client import ClobClient
from keys import api_key  # Import only the API key
from py_clob_client.clob_types import OpenOrderParams

# Replace with your actual host and chain ID
host = "https://clob.polymarket.com"
chain_id = 137  # Polygon Mainnet

# Initialize the client with only the host, key, and chain_id
client = ClobClient(
    host,
    key=api_key,
    chain_id=chain_id
)

# Initialize variables for pagination
markets_list = []
next_cursor = None

# Fetch all available markets using pagination
while True:
    try:
        # Print the cursor value for debugging
        print(f"Fetching markets with next_cursor: {next_cursor}")

        # Make the API call based on the cursor value
        if next_cursor is None:
            response = client.get_markets()
        else:
            response = client.get_markets(next_cursor=next_cursor)

        # Print the raw response for debugging
        print(f"API Response: {json.dumps(response, indent=2)}")

        # Check if the response is successful and contains data
        if 'data' not in response:
            print("No data found in response.")
            break

        markets_list.extend(response['data'])
        next_cursor = response.get("next_cursor")

        # Exit loop if there's no next_cursor indicating no more data to fetch
        if not next_cursor:
            break

    except Exception as e:
        # Print the exception details for debugging
        print(f"Exception occurred: {e}")
        print(f"Exception details: {e.__class__.__name__}")
        print(f"Error message: {e.args}")
        break

# Debugging step: Print out the raw data to understand its structure
print("Raw Market Data:")
print(json.dumps(markets_list, indent=2))

# Dynamically extract all keys from the markets to create the CSV columns
csv_columns = set()
for market in markets_list:
    csv_columns.update(market.keys())
    # Also include nested keys like tokens
    if 'tokens' in market:
        csv_columns.update({f"token_{key}" for token in market['tokens'] for key in token.keys()})

csv_columns = sorted(csv_columns)  # Sort columns alphabetically for consistency

# Writing to CSV
csv_file = "markets_data.csv"
try:
    with open(csv_file, 'w', newline='') as csvfile:
        writer = csv.DictWriter(csvfile, fieldnames=csv_columns)
        writer.writeheader()
        for market in markets_list:
            row = {}
            for key in csv_columns:
                # Handling nested 'tokens' structure
                if key.startswith("token_"):
                    token_key = key[len("token_"):]
                    row[key] = ', '.join([str(token.get(token_key, 'N/A')) for token in market.get('tokens', [])])
                else:
                    row[key] = market.get(key, 'N/A')
            writer.writerow(row)
    print(f"Data has been written to {csv_file} successfully.")
except IOError as e:
    print(f"Error writing to CSV: {e}")

Output CSV

If all goes as planned you will now have a giant CSV file named markets_data.csv with all the different markets and their values. You can now build on this code to manipulate it to your needs.

I finally installed this EG4 battery and inverter to power my house. You can read parts 1 and 2 here if you’re curious why I started this project. I did end up purchasing two batteries instead of one. A single inverter can support up to three batteries per the manufacturer. In my current configuration, I have a 28.6kWh capacity(2 batteries in parallel) which so far appears sufficient to support my house in the peak of July for 3 hours.

Too Small

My first attempt at building this project was with one battery with a 14.3kWh capacity. Remember the original goal was to eliminate all energy from the grid between 3-6 PM when energy is very expensive. You can see below in a couple of examples I was using too much energy and the battery would die. Then I would pull energy from the grid as indicated by that red bar. This was the last week before I installed the second battery.

Just Right

Here is the week after installing the second battery giving me a 28.6kWh capacity.

There is still some red in here when I was testing a few things and the battery was off. Also on the 29th I set the state of charge (SOC) level too low and the battery breaker tripped. EG4 recommends not depleting these any less than 20% SOC. This caused me to lose the battery discharging that entire day as indicated by the 3 red bars.

The EG4 interface was a bit tricky to understand at first. But essentially you just want to configure it to discharge the battery during certain hours and stop with the state of charge gets to a certain level.

The SOC cut-off level can also be configured here.

We can then configure the battery to charge starting at midnight

So essentially all the battery is doing is discharging between 3-6PM and charging at midnight.

Measuring current

This inverter also comes with CT clamps. You stick both of these on each leg of your 220v from your electricity provider. This allows you to monitor the amount of electricity you’re using for your entire house so you don’t back feed any electricity into the grid. You can check these options below to make sure the inverter does not send any electricity upstream.

Cost

Because I had to purchase two batteries and an inverter the cost was a bit more than I anticipated. My total cost for the main components was $11,683.30. I bought it from a local company in Arizona, San Tan Solar. The Residential Clean Energy Credit gives you 30% off the cost bringing the final number to $8,178.31 for 28.6kWh of battery and an inverter. The ultimate goal is to offset all of my energy from 2-8 PM with the solar and the current battery. This is just phase one of a larger project that will include solar. However, now that the inverter is installed I am ready to simply plug in solar panels.

Savings

The savings will be a little difficult to calculate until I’ve generated some usage statistics in my new house. However, below is SRP’s standard rates. We can now switch to the SRP 3-6 program and get all of our energy to about 10c per kWh which is a 30-40% savings. Again, the ultimate goal is to convert this into a solar/battery setup and offset all of our usage from 2-8 PM. This will drastically cut costs as all of our electricity will then be 5c per kWh reducing the cost 60-70% per kWh.

In the first part of this series, we discussed why building a DIY Powerwall is a smart move to offset peak demand costs. In this part, we’ll focus on how to determine the appropriate battery size for your needs using historical usage data from your SRP bills. The Python program below will output these charts and recommendations.

Output

The max you used during any 2-8 PM period is 58.90 kWh on 2021-09-05. Based on historical usage, this battery size would eliminate your electricity usage during peak hours.

The average you used during all 2-8 PM periods is 10.92 kWh. Based on historical usage, a battery of this size would eliminate your peak electricity usage on average.

If you did not have solar, you would need a battery with a size of 87.20 kWh to eliminate the maximum demand during peak hours. This maximum was recorded on 2021-09-05.

If you did not have solar, you would need a battery with a size of 39.04 kWh to eliminate the average demand during peak hours.

If you did not have solar, you would need a battery with a size of 232.80 kWh to power your house for a full day based on the maximum daily consumption. This maximum was recorded on 2021-08-03.

If you did not have solar, you would need a battery with a size of 116.08 kWh to power your house for a full day based on the average daily consumption.

Because you have solar, this reduces your battery size by 32.45% to eliminate all your peak energy.

Because you have solar, this reduces your battery size by 72.02% to eliminate on average all of your peak energy.

Collecting your data

To use this program, you need to download your hourly usage data from SRP:

1. Log in to Your SRP Account:
   • Navigate to the usage section.
   • Select hourly usage and choose your date range.
   • Export the data to Excel for the categories: net energy, generation, and usage. If you do not have solar, you may only have usage data, which is fine.
2. Data Export:
   • Download the data for May through October to focus on summer consumption months, as winter usage without AC is significantly lower.
   • Export data for multiple past years to allow the program to determine maximum and average values accurately.

You should now have some files that look like this.

With your data files ready, you can now run the Python program:

Time to buy the equipment

Now that you know your required battery size, you can begin shopping for components and building your DIY Powerwall. Stay tuned for the next part, where we’ll dive into the construction process!