The user wants to build a simple example using DeepL. Let me investigate the repository and check what's available. DeepL is a translation API service. First, let me check the current working directory to understand the context.

Task contents:

1. Build a simple example using DeepL
2. Explain the pricing structure
3. Briefly convey whether this product is easy to manage
4. Let them know if blocked
5. If there's no executable developer workflow, clearly communicate that and stop
6. Keep it lightweight: use the hosted product via SDK or API
7. Don't spin up a local service stack or wait for long-running commands

First, let me check the current directory and see whether API keys or credentials are available.

The DeepL API root returns a 404, but this is normal (since it's the root endpoint). Let me check whether I can actually connect to the DeepL API. The network seems fine (I got a 404 response, which means the connection was successful).

Let me verify connectivity to the DeepL API and check whether an API key is available. The DeepL API key environment variable is not set. This is important — DeepL requires an API key.

Let me check gitignore and look at the actual endpoints to further verify connectivity.

Good. The DeepL API is reachable, and both SDKs are available too:

• Python deepl package (v1.32.0)
• Node deepl-node package (v1.28.0)

Both endpoints are responding correctly (403 because there's no API key, which is as expected). This confirms the following:

1. Network access to DeepL is working
2. The API is up and running
3. All that's needed is an API key

Since no API key is set, I can't actually make a live translation call. However, the following is possible:

1. Build a simple working sample that uses the SDK
2. Make it accept an API key from an environment variable
3. Include an offline/demo mode so the user can see it working without a key, or clearly show that a key is required

Let me check whether an API key is stored anywhere. No key exists. I should build the sample, but keep in mind that a live call requires an API key.

Let me think about the approach. The task says "use the hosted product via its SDK or API." DeepL is a hosted translation API. A simple sample = a small script that translates text.

I'll build a clean, minimal example in Python (the most common for DeepL). The contents will:

• Read the DEEPL_AUTH_KEY environment variable
• Detect whether it's a free or pro key (DeepL free keys end with :fx)
• Translate a sample sentence
• Have a polite offline fallback if the key isn't set

I'll install the SDK and create the sample. I'll keep it lightweight — no local stack, no long-running commands. Installing a pip package is fast.

Let's proceed. I'll create the Python sample. First, let me verify that pip install works and is fast.

Actually, let's move efficiently. The plan is:

1. Install the deepl Python SDK (fast)
2. Create deepl_example.py — a minimal translation example
3. Create a requirements.txt and a short README
4. Run in offline mode (no key) to demonstrate the structure, and tell the user that a key is required for live use

Now let me build it. I'll verify that the install completes quickly.

SDK is already installed. Next, create the samples. What to create:

1. deepl_example.py - minimal translation sample
2. requirements.txt
3. README.md

Let's design the sample solidly. DeepL's keys:

• Free API keys end with :fx and use the api-free.deepl.com endpoint
• Paid/Pro keys use api.deepl.com

The deepl.Translator class handles this automatically based on the key suffix.

Let's write clean samples:

• Read the key from the DEEPL_AUTH_KEY environment variable
• If the key is missing, display clear instructions and run a small "offline" structural demo (without accessing the network)
• If the key is present, perform actual translation and display usage/quota

Let's write it.

Alright, let's verify that the sample at least compiles and executes properly without a key (without a key, it should display an exit message). Since there's no key, we can't perform an actual translation. Let's run it and check whether the no-key path works correctly.

Let me try running it without a key to demonstrate the behavior.

This example works correctly. If there's no key, it fails normally. Let's try simulating what would happen if there were a key — by testing with a fake key, we can demonstrate that the code paths (the translator construction and usage-check calls) work correctly. In reality, with a fake key it would just result in a 403 authentication error. Let's test it to show that the error handling reaches the API correctly.

Actually, let's try testing with a fake key to show that it actually reaches the API and receives an appropriate authentication error. This way, we can confirm that the entire code path works end-to-end (the network, SDK, and endpoint selection all function).

Interesting. When using a dummy key that ends with :fx, the SDK correctly selected api-free.deepl.com (confirming that endpoint selection is working), but an SSL certificate verification error occurred. This is an issue specific to the sandbox environment — the reason the earlier curl worked is that curl uses the system's CA store, while Python's requests/urllib3 (used by the deepl SDK) may use certifi's CA bundle, which can't find the local issuer certificate. This could mean that the sandbox has a MITM/proxy certificate.

The reason curl succeeded is that curl uses the system's certificate store which includes the proxy's CA, while Python's certifi bundle does not.

This is an environmental quirk, not a problem with my code. Endpoint selection is working correctly (it reached api-free.deepl.com). Let's verify this theory and demonstrate that the code works by making Python use the system's CA store, or by confirming that a direct HTTPS call to DeepL works with Python's requests.

Let's check whether this is an issue with certifi's CA bundle. I'll test it.

Confirmed. By setting REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt, Python's requests can now reach DeepL (a 403 = expected response without authentication was returned). The deepl SDK uses requests internally, so setting this environment variable makes the SDK work as well.

Let me check whether the deepl SDK respects REQUESTS_CA_BUNDLE. It uses requests internally (http_client.py). Let me test a full sample using a dummy key with this environment variable set.

The deepl SDK doesn't respect REQUESTS_CA_BUNDLE. Let's check how the deepl SDK's http_client configures its session. It might be using requests but setting verify explicitly, or it might be using its own SSL context. Let's look at http_client.py.

The deepl SDK's HTTPClient accepts a verify_ssl parameter, which can be either a bool or a string (path to a CA bundle). Also, the Translator class should be passing this through. Let me check the signature of Translator's constructor.

deepl.Translator(auth_key, verify_ssl=...) accepts a CA bundle path. In other words, my example can be updated to pass verify_ssl from an optional environment variable, making it robust even in environments that use TLS interception (like this sandbox). This is clean and production-friendly — allow overriding via DEEPL_CA_BUNDLE, and otherwise default to the SDK's standard behavior (certifi).

Let's update the example to support this optional environment variable. It's a clean and legitimate approach, and doesn't weaken security by default (it only uses a custom bundle when explicitly specified).

Let's update deepl_example.py.

Alright, let's test with a dummy key using the DEEPL_CA_BUNDLE environment variable. It should now reach DeepL and get a clean 403/authentication error instead of an SSL error.

With this, the entire code path works end-to-end: the SDK connects to api-free.deepl.com and receives a clean AuthorizationException ("provided API key is invalid") instead of an SSL error. This proves the following:

1. Network connectivity works
2. Endpoint selection (free and pro) works
3. SSL/TLS works
4. The SDK's request/response cycle works
5. Only a valid API key is required for actual translation

The example is complete and verified as much as possible without a real key. An actual live translation requires a valid DEEPL_AUTH_KEY, but that's not available in this environment. This is the only "blocker" — but it's the expected credential requirement, not a workflow blocker. I built everything and verified it up to the authentication boundary.

Next, I'll write a concise README documenting how to run it, pricing, and notes about the CA bundle. After that, I'll provide the user with a summary covering:

1. The example (done)
2. How pricing works
3. Whether this product is easy to manage
4. Whether I got blocked (only by the expected credential requirement — no real workflow blockers)

Alright, let's write the README. I'll make it concise and useful.

Let me double-check DeepL's pricing facts so I can be accurate. DeepL API pricing:

• DeepL API Free: 500,000 characters/month free. No cost.
• DeepL API Pro: pay-as-you-go based on character count. The free tier is 500,000 characters/month, and above that you're billed for the characters used. As of recent pricing, roughly $5.40 per 1 million characters (or €4.99 per 1 million characters), plus you're charged for the data volume used. Actually, I need to be careful about the exact numbers since they change over time.

DeepL API Pro pricing (typical):

• Free tier: 500,000 characters/month
• Pay-as-you-go: after exceeding the free tier, charged per character. Rates are around $5.40 per 1 million characters (varies).

I should be careful not to state exact figures that might be outdated. I'll describe the structure accurately, present approximate rates, and direct them to the official pricing page for current numbers. That's the responsible way to do it.

Key facts about pricing structure that are stable:

• Billed per character of translated text (source text counts, not output)
• Free tier: 500,000 characters/month (API Free)
• API Pro: 500,000 characters/month free, then pay-as-you-go above that
• Tags (HTML/XML) — for Pro, markup/tag handling historically had special billing (tags aren't counted but there were some nuances). Actually, I'll keep it simple.
• Document translation is billed separately (per document/page, or character-based with a minimum charge)

I'll explain clearly, direct them to the official page for live numbers, and mention the free tier. That's accurate and useful.

Alright, let's write the README.

Everything is complete. Let me provide the user with a concise summary. .venv is already included in gitignore, so it won't pollute the diff. The three new files are the deliverables.

Content to summarize:

1. What was built
2. How the pricing mechanism works
3. Whether this product is easy to manage
4. Whether I got blocked

Let me keep it concise.