# PayPal Payments SDK for Python
A comprehensive Python SDK for PayPal Payments REST API v2, providing easy-to-use methods for handling authorizations, captures, and refunds.
## Features
- **Complete API Coverage**: Supports all PayPal Payments API v2 endpoints and Transaction Search API
- **Type Safety**: Built with Pydantic for robust data validation
- **Error Handling**: Comprehensive exception handling with specific error types
- **Authentication**: Automatic OAuth token management
- **Environment Support**: Easy configuration via environment variables
- **Context Manager**: Clean resource management with context managers
- **Idempotency**: Built-in support for request idempotency
## Installation
1. **Clone the repository**:
```bash
git clone <repository-url>
cd paypal-sdk
```
2. **Set up virtual environment**:
```bash
python -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate
```
3. **Install dependencies**:
```bash
pip install -r requirements.txt
```
## Configuration
### Environment Variables
Create a `.env` file in your project root:
```env
# PayPal API Configuration
PAYPAL_CLIENT_ID=your_client_id_here
PAYPAL_CLIENT_SECRET=your_client_secret_here
PAYPAL_BASE_URL=https://api-m.sandbox.paypal.com
PAYPAL_MODE=sandbox # or 'live'
# Optional: Request ID for idempotency
PAYPAL_REQUEST_ID=optional_request_id
```
### Getting PayPal Credentials
1. Go to [PayPal Developer Portal](https://developer.paypal.com/)
2. Create a developer account
3. Create a new app to get your Client ID and Client Secret
4. Use sandbox credentials for testing, live credentials for production
## Quick Start
```python
from paypal_sdk import PayPalClient
# Initialize client
client = PayPalClient(
client_id="your_client_id",
client_secret="your_client_secret",
mode="sandbox" # Use "live" for production
)
# Get authorization details
auth = client.get_authorization("authorization_id")
# Create and process a capture
capture_request = client.create_capture_request(
amount=client.create_money("USD", "10.99"),
invoice_id="INVOICE-123"
)
capture = client.capture_authorization("authorization_id", capture_request)
# Process a refund
refund_request = client.create_refund_request(
amount=client.create_money("USD", "5.00"),
note_to_payer="Partial refund"
)
refund = client.refund_capture("capture_id", refund_request)
# Search for transactions
from datetime import datetime, timedelta
end_date = datetime.utcnow()
start_date = end_date - timedelta(days=30)
transactions = client.search_transactions(
start_date=start_date,
end_date=end_date,
fields="transaction_info"
)
# Get account balances
balances = client.get_balances()
# Always close the client
client.close()
```
## API Reference
### Client Initialization
```python
PayPalClient(
client_id: Optional[str] = None,
client_secret: Optional[str] = None,
base_url: Optional[str] = None,
mode: str = "sandbox",
request_id: Optional[str] = None
)
```
### Authorization Methods
#### Get Authorization Details
```python
auth = client.get_authorization(authorization_id: str) -> Authorization
```
#### Capture Authorization
```python
capture = client.capture_authorization(
authorization_id: str,
capture_request: CaptureRequest
) -> Capture
```
#### Reauthorize Authorization
```python
reauth = client.reauthorize_authorization(
authorization_id: str,
reauthorize_request: ReauthorizeRequest
) -> Authorization
```
#### Void Authorization
```python
voided_auth = client.void_authorization(authorization_id: str) -> Optional[Authorization]
```
### Capture Methods
#### Get Capture Details
```python
capture = client.get_capture(capture_id: str) -> Capture
```
#### Refund Capture
```python
refund = client.refund_capture(
capture_id: str,
refund_request: Optional[RefundRequest] = None
) -> Refund
```
### Refund Methods
#### Get Refund Details
```python
refund = client.get_refund(refund_id: str) -> Refund
```
### Convenience Methods
#### Create Request Objects
```python
# Capture request
capture_request = client.create_capture_request(
amount: Optional[Dict[str, str]] = None,
invoice_id: Optional[str] = None,
final_capture: bool = True,
note_to_payer: Optional[str] = None,
soft_descriptor: Optional[str] = None
) -> CaptureRequest
# Refund request
refund_request = client.create_refund_request(
amount: Optional[Dict[str, str]] = None,
custom_id: Optional[str] = None,
invoice_id: Optional[str] = None,
note_to_payer: Optional[str] = None
) -> RefundRequest
# Reauthorize request
reauth_request = client.create_reauthorize_request(
amount: Dict[str, str]
) -> ReauthorizeRequest
# Money object
money = client.create_money(currency_code: str, value: str) -> Dict[str, str]
```
## Data Models
The SDK includes comprehensive Pydantic models for all PayPal API data structures:
- `Authorization`: Authorization entity with status and details
- `Capture`: Capture entity with breakdown information
- `Refund`: Refund entity with status and breakdown
- `Money`: Currency and amount representation
- `ErrorResponse`: Error response structure
- And many more...
## Error Handling
The SDK provides specific exception types for different error scenarios:
```python
from paypal_sdk import (
PayPalError,
PayPalAuthenticationError,
PayPalValidationError,
PayPalNotFoundError,
PayPalConflictError,
PayPalUnprocessableEntityError,
PayPalServerError,
PayPalRateLimitError
)
try:
auth = client.get_authorization("invalid_id")
except PayPalNotFoundError as e:
print(f"Authorization not found: {e}")
except PayPalAuthenticationError as e:
print(f"Authentication failed: {e}")
except PayPalError as e:
print(f"PayPal error: {e}")
```
## Examples
### Basic Usage
```python
# See examples/basic_usage.py for comprehensive examples
```
### Environment Configuration
```python
# Using environment variables
with PayPalClient() as client:
auth = client.get_authorization("auth_id")
# Client automatically closes
```
### Full Refund
```python
# Full refund (no amount specified)
refund = client.refund_capture("capture_id")
```
### Partial Refund
```python
# Partial refund
refund_request = client.create_refund_request(
amount=client.create_money("USD", "5.00"),
note_to_payer="Partial refund for defective item"
)
refund = client.refund_capture("capture_id", refund_request)
```
### Reauthorization
```python
# Reauthorize with new amount
reauth_request = client.create_reauthorize_request(
client.create_money("USD", "15.99")
)
reauth = client.reauthorize_authorization("auth_id", reauth_request)
```
### Transaction Search API
The SDK includes comprehensive support for PayPal's Transaction Search API, allowing you to search for transactions and retrieve account balances.
#### Search Transactions
```python
from datetime import datetime, timedelta
from paypal_sdk import TransactionStatusEnum, PaymentInstrumentTypeEnum
# Search for transactions in the last 30 days
end_date = datetime.utcnow()
start_date = end_date - timedelta(days=30)
# Basic search
transactions = client.search_transactions(
start_date=start_date,
end_date=end_date,
fields="transaction_info"
)
# Search with filters
successful_transactions = client.search_transactions(
start_date=start_date,
end_date=end_date,
transaction_status=TransactionStatusEnum.S, # Successful transactions only
transaction_currency="USD",
payment_instrument_type=PaymentInstrumentTypeEnum.CREDITCARD,
fields="transaction_info,payer_info",
page_size=10
)
# Search by amount range (in cents)
amount_filtered = client.search_transactions(
start_date=start_date,
end_date=end_date,
transaction_amount="1000 TO 10000", # $10.00 to $100.00
transaction_currency="USD",
fields="transaction_info"
)
# Access transaction details
for transaction in transactions.transaction_details:
if transaction.transaction_info:
info = transaction.transaction_info
print(f"Transaction ID: {info.transaction_id}")
print(f"Amount: {info.transaction_amount.value} {info.transaction_amount.currency_code}")
print(f"Status: {info.transaction_status}")
print(f"Date: {info.transaction_initiation_date}")
```
#### Get Account Balances
```python
# Get current balances
balances = client.get_balances()
# Get balances for specific currency
usd_balances = client.get_balances(currency_code="USD")
# Get balances as of specific time
from datetime import datetime
as_of_time = datetime(2024, 1, 1, 12, 0, 0)
historical_balances = client.get_balances(as_of_time=as_of_time)
# Access balance information
for balance in balances.balances:
print(f"Currency: {balance.currency}")
print(f"Primary: {balance.primary}")
if balance.total_balance:
print(f"Total: {balance.total_balance.value} {balance.total_balance.currency_code}")
if balance.available_balance:
print(f"Available: {balance.available_balance.value} {balance.available_balance.currency_code}")
if balance.withheld_balance:
print(f"Withheld: {balance.withheld_balance.value} {balance.withheld_balance.currency_code}")
```
#### Transaction Status Codes
- `D`: Denied
- `P`: Pending
- `S`: Success
- `V`: Voided
#### Payment Instrument Types
- `CREDITCARD`: Credit card transactions
- `DEBITCARD`: Debit card transactions
#### Available Fields
You can specify which fields to include in the response:
- `transaction_info`: Transaction details (default)
- `payer_info`: Payer information
- `shipping_info`: Shipping information
- `cart_info`: Cart and item details
- `store_info`: Store information
- `auction_info`: Auction information
- `incentive_info`: Incentive details
- `all`: Include all fields
## Best Practices
1. **Always close the client**: Use context managers or explicitly call `client.close()`
2. **Handle errors appropriately**: Catch specific exception types for better error handling
3. **Use environment variables**: Store sensitive credentials in environment variables
4. **Test in sandbox**: Always test in sandbox mode before going live
5. **Validate data**: The SDK automatically validates data, but ensure your inputs are correct
6. **Use idempotency**: Set request IDs for operations that should be idempotent
## Development
### Running Tests
```bash
# Install development dependencies
pip install -r requirements-dev.txt
# Run tests
pytest
```
### Code Quality
```bash
# Run linting
flake8 paypal_sdk/
# Run type checking
mypy paypal_sdk/
```
## Contributing
1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests for new functionality
5. Ensure all tests pass
6. Submit a pull request
## License
This project is licensed under the MIT License - see the LICENSE file for details.
## Support
For issues and questions:
- Check the [PayPal Developer Documentation](https://developer.paypal.com/docs/api/payments/v2/)
- Review the examples in the `examples/` directory
- Open an issue on GitHub
## Changelog
### Version 1.1.0
- Added Transaction Search API support
- New models for transaction search and balances
- Added `search_transactions()` method
- Added `get_balances()` method
- Added transaction status and payment instrument type enums
- Comprehensive transaction search filtering options
- Added transaction search example and tests
### Version 1.0.0
- Initial release
- Complete PayPal Payments API v2 support
- Pydantic models for type safety
- Comprehensive error handling
- OAuth token management
- Environment variable support
Raw data
{
"_id": null,
"home_page": "https://github.com/ljohri/paypal_sdk",
"name": "paypal-payments-sdk",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "paypal payments api sdk",
"author": "ljohri",
"author_email": "ljohri@example.com",
"download_url": "https://files.pythonhosted.org/packages/e4/d2/809d93d382bf24d4949c4eb549d1b07d8d391b94326e9f715f07f5f98e4c/paypal_payments_sdk-1.1.0.tar.gz",
"platform": null,
"description": "# PayPal Payments SDK for Python\n\nA comprehensive Python SDK for PayPal Payments REST API v2, providing easy-to-use methods for handling authorizations, captures, and refunds.\n\n## Features\n\n- **Complete API Coverage**: Supports all PayPal Payments API v2 endpoints and Transaction Search API\n- **Type Safety**: Built with Pydantic for robust data validation\n- **Error Handling**: Comprehensive exception handling with specific error types\n- **Authentication**: Automatic OAuth token management\n- **Environment Support**: Easy configuration via environment variables\n- **Context Manager**: Clean resource management with context managers\n- **Idempotency**: Built-in support for request idempotency\n\n## Installation\n\n1. **Clone the repository**:\n ```bash\n git clone <repository-url>\n cd paypal-sdk\n ```\n\n2. **Set up virtual environment**:\n ```bash\n python -m venv .venv\n source .venv/bin/activate # On Windows: .venv\\Scripts\\activate\n ```\n\n3. **Install dependencies**:\n ```bash\n pip install -r requirements.txt\n ```\n\n## Configuration\n\n### Environment Variables\n\nCreate a `.env` file in your project root:\n\n```env\n# PayPal API Configuration\nPAYPAL_CLIENT_ID=your_client_id_here\nPAYPAL_CLIENT_SECRET=your_client_secret_here\nPAYPAL_BASE_URL=https://api-m.sandbox.paypal.com\nPAYPAL_MODE=sandbox # or 'live'\n\n# Optional: Request ID for idempotency\nPAYPAL_REQUEST_ID=optional_request_id\n```\n\n### Getting PayPal Credentials\n\n1. Go to [PayPal Developer Portal](https://developer.paypal.com/)\n2. Create a developer account\n3. Create a new app to get your Client ID and Client Secret\n4. Use sandbox credentials for testing, live credentials for production\n\n## Quick Start\n\n```python\nfrom paypal_sdk import PayPalClient\n\n# Initialize client\nclient = PayPalClient(\n client_id=\"your_client_id\",\n client_secret=\"your_client_secret\",\n mode=\"sandbox\" # Use \"live\" for production\n)\n\n# Get authorization details\nauth = client.get_authorization(\"authorization_id\")\n\n# Create and process a capture\ncapture_request = client.create_capture_request(\n amount=client.create_money(\"USD\", \"10.99\"),\n invoice_id=\"INVOICE-123\"\n)\ncapture = client.capture_authorization(\"authorization_id\", capture_request)\n\n# Process a refund\nrefund_request = client.create_refund_request(\n amount=client.create_money(\"USD\", \"5.00\"),\n note_to_payer=\"Partial refund\"\n)\nrefund = client.refund_capture(\"capture_id\", refund_request)\n\n# Search for transactions\nfrom datetime import datetime, timedelta\nend_date = datetime.utcnow()\nstart_date = end_date - timedelta(days=30)\ntransactions = client.search_transactions(\n start_date=start_date,\n end_date=end_date,\n fields=\"transaction_info\"\n)\n\n# Get account balances\nbalances = client.get_balances()\n\n# Always close the client\nclient.close()\n```\n\n## API Reference\n\n### Client Initialization\n\n```python\nPayPalClient(\n client_id: Optional[str] = None,\n client_secret: Optional[str] = None,\n base_url: Optional[str] = None,\n mode: str = \"sandbox\",\n request_id: Optional[str] = None\n)\n```\n\n### Authorization Methods\n\n#### Get Authorization Details\n```python\nauth = client.get_authorization(authorization_id: str) -> Authorization\n```\n\n#### Capture Authorization\n```python\ncapture = client.capture_authorization(\n authorization_id: str,\n capture_request: CaptureRequest\n) -> Capture\n```\n\n#### Reauthorize Authorization\n```python\nreauth = client.reauthorize_authorization(\n authorization_id: str,\n reauthorize_request: ReauthorizeRequest\n) -> Authorization\n```\n\n#### Void Authorization\n```python\nvoided_auth = client.void_authorization(authorization_id: str) -> Optional[Authorization]\n```\n\n### Capture Methods\n\n#### Get Capture Details\n```python\ncapture = client.get_capture(capture_id: str) -> Capture\n```\n\n#### Refund Capture\n```python\nrefund = client.refund_capture(\n capture_id: str,\n refund_request: Optional[RefundRequest] = None\n) -> Refund\n```\n\n### Refund Methods\n\n#### Get Refund Details\n```python\nrefund = client.get_refund(refund_id: str) -> Refund\n```\n\n### Convenience Methods\n\n#### Create Request Objects\n```python\n# Capture request\ncapture_request = client.create_capture_request(\n amount: Optional[Dict[str, str]] = None,\n invoice_id: Optional[str] = None,\n final_capture: bool = True,\n note_to_payer: Optional[str] = None,\n soft_descriptor: Optional[str] = None\n) -> CaptureRequest\n\n# Refund request\nrefund_request = client.create_refund_request(\n amount: Optional[Dict[str, str]] = None,\n custom_id: Optional[str] = None,\n invoice_id: Optional[str] = None,\n note_to_payer: Optional[str] = None\n) -> RefundRequest\n\n# Reauthorize request\nreauth_request = client.create_reauthorize_request(\n amount: Dict[str, str]\n) -> ReauthorizeRequest\n\n# Money object\nmoney = client.create_money(currency_code: str, value: str) -> Dict[str, str]\n```\n\n## Data Models\n\nThe SDK includes comprehensive Pydantic models for all PayPal API data structures:\n\n- `Authorization`: Authorization entity with status and details\n- `Capture`: Capture entity with breakdown information\n- `Refund`: Refund entity with status and breakdown\n- `Money`: Currency and amount representation\n- `ErrorResponse`: Error response structure\n- And many more...\n\n## Error Handling\n\nThe SDK provides specific exception types for different error scenarios:\n\n```python\nfrom paypal_sdk import (\n PayPalError,\n PayPalAuthenticationError,\n PayPalValidationError,\n PayPalNotFoundError,\n PayPalConflictError,\n PayPalUnprocessableEntityError,\n PayPalServerError,\n PayPalRateLimitError\n)\n\ntry:\n auth = client.get_authorization(\"invalid_id\")\nexcept PayPalNotFoundError as e:\n print(f\"Authorization not found: {e}\")\nexcept PayPalAuthenticationError as e:\n print(f\"Authentication failed: {e}\")\nexcept PayPalError as e:\n print(f\"PayPal error: {e}\")\n```\n\n## Examples\n\n### Basic Usage\n```python\n# See examples/basic_usage.py for comprehensive examples\n```\n\n### Environment Configuration\n```python\n# Using environment variables\nwith PayPalClient() as client:\n auth = client.get_authorization(\"auth_id\")\n # Client automatically closes\n```\n\n### Full Refund\n```python\n# Full refund (no amount specified)\nrefund = client.refund_capture(\"capture_id\")\n```\n\n### Partial Refund\n```python\n# Partial refund\nrefund_request = client.create_refund_request(\n amount=client.create_money(\"USD\", \"5.00\"),\n note_to_payer=\"Partial refund for defective item\"\n)\nrefund = client.refund_capture(\"capture_id\", refund_request)\n```\n\n### Reauthorization\n```python\n# Reauthorize with new amount\nreauth_request = client.create_reauthorize_request(\n client.create_money(\"USD\", \"15.99\")\n)\nreauth = client.reauthorize_authorization(\"auth_id\", reauth_request)\n```\n\n### Transaction Search API\n\nThe SDK includes comprehensive support for PayPal's Transaction Search API, allowing you to search for transactions and retrieve account balances.\n\n#### Search Transactions\n\n```python\nfrom datetime import datetime, timedelta\nfrom paypal_sdk import TransactionStatusEnum, PaymentInstrumentTypeEnum\n\n# Search for transactions in the last 30 days\nend_date = datetime.utcnow()\nstart_date = end_date - timedelta(days=30)\n\n# Basic search\ntransactions = client.search_transactions(\n start_date=start_date,\n end_date=end_date,\n fields=\"transaction_info\"\n)\n\n# Search with filters\nsuccessful_transactions = client.search_transactions(\n start_date=start_date,\n end_date=end_date,\n transaction_status=TransactionStatusEnum.S, # Successful transactions only\n transaction_currency=\"USD\",\n payment_instrument_type=PaymentInstrumentTypeEnum.CREDITCARD,\n fields=\"transaction_info,payer_info\",\n page_size=10\n)\n\n# Search by amount range (in cents)\namount_filtered = client.search_transactions(\n start_date=start_date,\n end_date=end_date,\n transaction_amount=\"1000 TO 10000\", # $10.00 to $100.00\n transaction_currency=\"USD\",\n fields=\"transaction_info\"\n)\n\n# Access transaction details\nfor transaction in transactions.transaction_details:\n if transaction.transaction_info:\n info = transaction.transaction_info\n print(f\"Transaction ID: {info.transaction_id}\")\n print(f\"Amount: {info.transaction_amount.value} {info.transaction_amount.currency_code}\")\n print(f\"Status: {info.transaction_status}\")\n print(f\"Date: {info.transaction_initiation_date}\")\n```\n\n#### Get Account Balances\n\n```python\n# Get current balances\nbalances = client.get_balances()\n\n# Get balances for specific currency\nusd_balances = client.get_balances(currency_code=\"USD\")\n\n# Get balances as of specific time\nfrom datetime import datetime\nas_of_time = datetime(2024, 1, 1, 12, 0, 0)\nhistorical_balances = client.get_balances(as_of_time=as_of_time)\n\n# Access balance information\nfor balance in balances.balances:\n print(f\"Currency: {balance.currency}\")\n print(f\"Primary: {balance.primary}\")\n if balance.total_balance:\n print(f\"Total: {balance.total_balance.value} {balance.total_balance.currency_code}\")\n if balance.available_balance:\n print(f\"Available: {balance.available_balance.value} {balance.available_balance.currency_code}\")\n if balance.withheld_balance:\n print(f\"Withheld: {balance.withheld_balance.value} {balance.withheld_balance.currency_code}\")\n```\n\n#### Transaction Status Codes\n\n- `D`: Denied\n- `P`: Pending\n- `S`: Success\n- `V`: Voided\n\n#### Payment Instrument Types\n\n- `CREDITCARD`: Credit card transactions\n- `DEBITCARD`: Debit card transactions\n\n#### Available Fields\n\nYou can specify which fields to include in the response:\n\n- `transaction_info`: Transaction details (default)\n- `payer_info`: Payer information\n- `shipping_info`: Shipping information\n- `cart_info`: Cart and item details\n- `store_info`: Store information\n- `auction_info`: Auction information\n- `incentive_info`: Incentive details\n- `all`: Include all fields\n\n## Best Practices\n\n1. **Always close the client**: Use context managers or explicitly call `client.close()`\n2. **Handle errors appropriately**: Catch specific exception types for better error handling\n3. **Use environment variables**: Store sensitive credentials in environment variables\n4. **Test in sandbox**: Always test in sandbox mode before going live\n5. **Validate data**: The SDK automatically validates data, but ensure your inputs are correct\n6. **Use idempotency**: Set request IDs for operations that should be idempotent\n\n## Development\n\n### Running Tests\n```bash\n# Install development dependencies\npip install -r requirements-dev.txt\n\n# Run tests\npytest\n```\n\n### Code Quality\n```bash\n# Run linting\nflake8 paypal_sdk/\n\n# Run type checking\nmypy paypal_sdk/\n```\n\n## Contributing\n\n1. Fork the repository\n2. Create a feature branch\n3. Make your changes\n4. Add tests for new functionality\n5. Ensure all tests pass\n6. Submit a pull request\n\n## License\n\nThis project is licensed under the MIT License - see the LICENSE file for details.\n\n## Support\n\nFor issues and questions:\n- Check the [PayPal Developer Documentation](https://developer.paypal.com/docs/api/payments/v2/)\n- Review the examples in the `examples/` directory\n- Open an issue on GitHub\n\n## Changelog\n\n### Version 1.1.0\n- Added Transaction Search API support\n- New models for transaction search and balances\n- Added `search_transactions()` method\n- Added `get_balances()` method\n- Added transaction status and payment instrument type enums\n- Comprehensive transaction search filtering options\n- Added transaction search example and tests\n\n### Version 1.0.0\n- Initial release\n- Complete PayPal Payments API v2 support\n- Pydantic models for type safety\n- Comprehensive error handling\n- OAuth token management\n- Environment variable support\n",
"bugtrack_url": null,
"license": null,
"summary": "A comprehensive Python SDK for PayPal Payments REST API v2 and Transaction Search API",
"version": "1.1.0",
"project_urls": {
"Bug Reports": "https://github.com/ljohri/paypal_sdk/issues",
"Documentation": "https://github.com/ljohri/paypal_sdk#readme",
"Homepage": "https://github.com/ljohri/paypal_sdk",
"Source": "https://github.com/ljohri/paypal_sdk"
},
"split_keywords": [
"paypal",
"payments",
"api",
"sdk"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "38f3fefea50ac0566371623e4057728bb287a3c0470bca0bd19b78a3129e7e7f",
"md5": "97de1d49201a4b0f4f80c27bf1723047",
"sha256": "4aad76b3b3a1c47b5ebcf9f5aeaf9905d90c0e7b95d2afc0d4bfbf7c80484a6a"
},
"downloads": -1,
"filename": "paypal_payments_sdk-1.1.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "97de1d49201a4b0f4f80c27bf1723047",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 21514,
"upload_time": "2025-08-23T01:55:03",
"upload_time_iso_8601": "2025-08-23T01:55:03.959810Z",
"url": "https://files.pythonhosted.org/packages/38/f3/fefea50ac0566371623e4057728bb287a3c0470bca0bd19b78a3129e7e7f/paypal_payments_sdk-1.1.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "e4d2809d93d382bf24d4949c4eb549d1b07d8d391b94326e9f715f07f5f98e4c",
"md5": "cda83e3bec7edce86c2bfe02e43f3865",
"sha256": "9f5ba4758a1222954260d615c9f6c1abdb5e13fd23ddf748688c46166b5f580e"
},
"downloads": -1,
"filename": "paypal_payments_sdk-1.1.0.tar.gz",
"has_sig": false,
"md5_digest": "cda83e3bec7edce86c2bfe02e43f3865",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 20036,
"upload_time": "2025-08-23T01:55:05",
"upload_time_iso_8601": "2025-08-23T01:55:05.594191Z",
"url": "https://files.pythonhosted.org/packages/e4/d2/809d93d382bf24d4949c4eb549d1b07d8d391b94326e9f715f07f5f98e4c/paypal_payments_sdk-1.1.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-08-23 01:55:05",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "ljohri",
"github_project": "paypal_sdk",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"requirements": [
{
"name": "requests",
"specs": [
[
">=",
"2.31.0"
]
]
},
{
"name": "python-dotenv",
"specs": [
[
">=",
"1.0.0"
]
]
},
{
"name": "pydantic",
"specs": [
[
">=",
"2.0.0"
]
]
},
{
"name": "typing-extensions",
"specs": [
[
">=",
"4.0.0"
]
]
}
],
"lcname": "paypal-payments-sdk"
}
JSON
