REST API

JFrog Platform Administration Documentation

ft:sourceType: Paligo

Platform Administration
General System Settings
General Settings
Direct Cloud Storage Download Settings
Look and Feel Settings (Branding)
Custom Message
Custom Login Dialog
Mail Server Configuration
Webhooks
Predefined Webhooks
Custom Webhooks
Test a Webhook
Event Types
Domain: Artifact
Domain: Artifact Properties
Domain: Docker
Domain: Build
Domain: Release Bundle
Domain: Distribution
Domain: Destination
Webhooks REST API Support
Trigger a GitHub Action using Custom Webhook
General Security Settings
General Configuration
Allow Anonymous Access
Hide Existence of Unauthorized Resources
Password Encryption Policy
Disable Basic Authentication Method
Hide Basic Authentication
Enable Token Generation via API
Multi-factor Authentication
View the Join Key
PDN Access Token and PDN Nodes Configuration
User Lock and Login Suspension
Password Expiration Policy
Manage API Keys
Passwords Encryption
Token Expiration
Hardening Security for Secrets
Centrally Secure Passwords
Secure Your Password
User Profile
Introduction to the User Profile
View the Profile
Unlock Your Profile
Add SSH Key
Bind OAuth Accounts
Change Your Personal Settings
Generate Identity Token
Change Your Email and Password
Password Reminder
API Key
JFrog API Key Deprecation Process
Work with API Keys (Until Deprecated)
API Keys REST API
Dashboard
Introduction to the Dashboard
Dashboard: Prerequisites and Guidelines
Global Trend Filters
Enable Trends
Increase Elasticsearch Shard Size
View JPD Health and Services
Check Data Replication Status
View Trends in the Dashboard
Storage Trends
Xray Insights
Incoming HTTP Requests Metrics
Performance Trends
Replication Trends
System Metrics
Remote Repository Requests Metrics
Users & Groups
Introduction to Users and Groups
Permissions
Introduction to Permissions
JFrog Platform Permission Migration
Security
Introduction to JFrog Platform Security
Security Keys Management
Manage Signing Keys
Manage RSA and GPG Key Pairs
Add RSA Keys Pairs
Generate RSA Keys
Upload RSA Keys
Configure Alpine Repositories with RSA Keys
Add GPG Key Pairs
Generate GPG Keys
Upload GPG Keys
Manage Vault RSA and GPG Key Pairs
Set up a New RSA/GPG Key in Vault
Change an Uploaded Key with a Vault Key
REST API Commands to Manage Keys
Manage WebStart and Jar Signing
Generate JAR Signing Keys
Set Your Keystore and JAR Signing Keys
Remove a JAR Signing Key Pair
Configure Virtual Repositories to Sign JARs
Manage Public Keys
Add a Public Key
Manage SSH Keys
Configure SSH Server Authentication
Configure User Authentication with your Public Key
Configure the GIT LFS or CLI Client
Include Pattern System Properties for SSH Configuration
Exclude Pattern System Properties for SSH Configuration
Supported Values By Algorithm Type for SSH Configuration
SCIM
Implemented SCIM Endpoints
Generate a Scoped Token for SCIM
Provisioning with Okta
Provisioning with Azure AD
Vault
How Does Vault Work?
Set up HashiCorp Vault Connectors
Connect HashiCorp Vault to the JFrog Platform Using REST API
Retrieve Signing Keys from HashiCorp Vault
REST API Support for Vault
LDAP
LDAP Configuration
LDAP Groups
LDAP Groups Usage
Manage Permissions for LDAP Groups
LDAP Group Synchronization Strategies
Synchronize LDAP Groups with the JPD Through the UI
Synchronize LDAP Groups with the JPD Using the REST API
Customize the LDAP Timeout / LDAP Referral Strategy
Enforce Dynamic Search of Attributes for LDAP Groups
Non-UI Authentication Cache for LDAP
Avoid Clear Text Passwords
Prevent Authentication Fallback to the Local Artifactory Realm
Using LDAPS (Secure LDAP)
Active Directory
Configure Active Directory
Import Active Directory Groups
Support for Nested Active Directory Groups
Using Secure Active Directory
SAML SSO
SAML SSO Configuration
SAML SSO Configuration with Okta
SAML-Based SSO Login Process
SAML-Based SSO Logout Process
SAML Profiles and Bindings
SAML Login Failure
Using API Key with SAML Users
OAuth SSO
OAuth SSO Usage
Configure OAuth
Add a New OAuth Provider
Use Query Params for OAuth
Enable Authorization Code Flow with PKCE
Enable and Disable Personal OAuth SSO
Binding Existing User Accounts
Create OAuth Provider Accounts
GitHub OAuth Setup
Google OAuth Provider Setup
Cloud Foundry UAA OAuth Setup
Use Secure OAuth
Use API Key with OAuth Users
Use OAuth on High Availability Setup
HTTP SSO
Configure HTTP SSO in JPD
Integrate Apache and Tomcat for HTTP SSO
Set Up a Reverse SSL Proxy for SSO
Modify Webserver Configuration File to Set Reverse SSL Proxy for SSO
Use API Key with HTTP-SSO Users
Atlassian Crowd and JIRA Integration
Configure Crowd Integration
Crowd Groups
Key Encryption
Activate and Deactivate Password Encryption
Export and Import the Artifactory Encryption Key
Logging in using Multi-factor Authentication
MFA Enrollment - First Time Login with MFA Enabled
Log in with Multi-factor Authentication
Access Tokens
Introduction to Access Tokens
Token Certificates
Resetting Token Certificates
Certificates in HA - Key Pair Propagation in an Existing HA Cluster
Using Tokens
Basic Authentication
Authorization Headers
Support Authentication for Non-existing Users
Generating Expirable Tokens
Using the Revocable and Persistency Thresholds
Revocable Expiry Threshold
Special Cases
Setting the Revocable Expiry Threshold
Persistency Threshold
Setting the Persistency Threshold
Relationship Between the Two Thresholds
Generating Refreshable Tokens
Generating Admin Tokens
Generating Scoped Tokens
Viewing the Scope of a Token
Creating an Admin Scoped Token
Creating an Admin Scoped Reference Token
Creating a User Scoped Token
Creating a Group Scoped Token
Generating Pairing Tokens
How do Pairing Tokens and Join Keys Differ?
Master Token
Supported Pairing Tokens
Pairing Tokens to Bind a JPD and a Mission Control Microservice
Pairing Tokens to Set up Cold Storage (Using the API)
Viewing and Revoking Tokens
Circle of Trust (Cross-Instance Authentication)
Why do I Need a Circle of Trust?
How to Establish a Circle of Trust
Security Restrictions
REST API
Get Root Certificate
Refresh Token
Create Token
Get Service ID
Revoke Token
Binding Tokens
Projects
Introduction to Projects
Projects Concepts and Terminology
Managing Project Roles and Members
Creating a Project
Managing Projects
Environments
Manage Custom Environments
Create a Custom Global Environment
Create a Custom Project Environment
Assign Environments to Global and Project Roles
Assign Environments to Repositories
Delete a Custom Environment
Cold Storage
Introduction to Cold Storage
Cold Storage Setup
Set Up Cold Storage Using the Platform UI
Set Up Cold Storage Using REST APIs
Manage Cold Storage Bindings
Optimize Cold Storage Performance
Working with Cold Storage
Set Up Retention Policies
What Happens after the Archive Policy is Created?
Manage Archiving Policies
Search and Restore Archived Artifacts or Packages
Monitor Archive and Restoration Operations
Work with Cold Storage Using REST APIs
Review Archive and Restore Logs
Cold Storage Limitations and Workarounds
Workers
Workers Service
Worker Limitations
TypeScript Code for Workers
TypeScript APIs
PlatformContext
PlatformClients
PlatformHttpClient
IPlatformHttpResponse
PlatformHttpClientError
Create a Before Download Worker
Before Download Worker Code Sample
Create an After Download Worker
After Download Worker Code Sample
Create a Before Upload Worker
Before Upload Worker Code Sample
Create an After Create Worker
After Create Worker Code Sample
Create an After Move Worker
After Move Worker Code Sample
Create an After Build Info Save Worker
After Build Info Save Worker Code Sample
Worker Repository Filter
Access Federation
Managing Platform Deployments
Register a Platform Deployment
View Platform Deployment Information
Delete Platform Deployments
Managing Licenses
Managing Licenses
License Management
Manage License Buckets
Obtain a License Bucket
Add a License Bucket
View License Bucket Information
Split a License Bucket
Attach Licenses to a License Bucket
Remove a License Bucket
Update Licenses in a License Bucket
Automate License Buckets Using JFrog CLI
Deploy and Release Licenses in a License Bucket with JFrog CLI
License Management for an Individual Artifactory or Artifactory Edge
Managing Proxies
Define Proxies
Configure an NTLM Proxy
Set Exclusions to the Default Proxy
Monitoring
Monitoring Storage
Monitor Binaries
Monitor the File Store
Monitor Repositories
Monitoring Replication
Monitoring Service Statuses
View the Service Statuses
Monitor Artifactory Microservices
Monitor Xray Microservices
Monitor Distribution Microservices
Monitor PDN Server
Monitor Insight Microservices
Monitor Mission Control Microservices
Monitoring Private Distribution Network (PDN) Traffic Consumption
Artifactory JMX MBeans
JMX MBeans Repositories
JMX MBeans Executor Pools
JMX MBeans Storage
JMX MBeans HTTP Connection Pools
JMX MBeans Logging
Regular Maintenance Operations
Managing Disk Space Usage
Logging
Log Files Location and Naming
Archived Logs
Log File Structure
Service Log
Request Log
Outbound Request Log
Router Request Log
Console Log
View Log Files from the UI
Send Logs to Syslog
Configure the logback library
Configure syslog on your machine
Configure Log Verbosity with Logback for Java-based Microservices
Configure Log Verbosity with System YAML for Non-Java Microservices
Log Analytics
New Relic
Splunk
Prometheus with Grafana
Elasticsearch with Kibana
Set Up Fluentd for Elasticsearch
View JFrog Log Data in Elasticsearch with Kibana
Datadog
Datadog Integration Installation and Setup
Datadog Integration Dashboards
Sumo Logic
Configure Log Analytics for Sumo Logic
Access Log
Audit Trail Log
Live Logs
Cloud Log Collection
Open Metrics
Artifactory Metrics
Xray Metrics
PDN Metrics
Pipelines Metrics
Usage Example - Prometheus
Configuring Log Rotation for Tomcat
Troubleshooting
Support Zone

All management of access tokens is done via REST API through the endpoints described below.

Back to home page