# Publishing a notebook as a gist #

A gist is a simple way to share a notebook or parts of a notebook with other users\. Unlike when you publish to a GitHub repository, you don't need to manage your gists; you can edit your gists directly in the browser\.

All project collaborators, who have administrator or editor permission, can share notebooks or parts of a notebook as gists\. The latest saved version of your notebook is published as a gist\.

Before you can create a gist, you must be logged in to GitHub and have authorized access to gists in GitHub from Watson Studio\. See [Publish notebooks on GitHub](https://dataplatform.cloud.ibm.com/docs/content/wsj/analyze-data/github-integration.html)\. If this information is missing, you are prompted for it\.

To publish a notebook as a gist:

<!-- <ol> -->

1.  Open the notebook in edit mode\.
2.  Click the GitHub integration icon (![Shows the upload icon](https://dataplatform.cloud.ibm.com/docs/content/wsj/analyze-data/images/upload.png)) and select **Publish as gist**\.

<!-- </ol> -->

Watch this video to see how to enable GitHub integration\.

Video disclaimer: Some minor steps and graphical elements in this video might differ from your platform\.

This video provides a visual method to learn the concepts and tasks in this documentation\.

<!-- <ul> -->

 *  Transcript
    
     Synchronize transcript with video
    
    <!-- <table "class="bx--data-table bx--data-table--zebra" style="border-collapse: collapse; border: none;" "> -->
    
    | Time  | Transcript                                                                                                                                                                  |
    | ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
    | 00:00 | This video shows you how to publish notebooks from your Watson Studio project to your GitHub account.                                                                      |
    | 00:07 | Navigate to your profile and settings.                                                                                                                                     |
    | 00:11 | On the "Integrations" tab, visit the link to generate a GitHub personal access token.                                                                                      |
    | 00:17 | Provide a descriptive name for the token and select the repo and gist scopes, then generate the token.                                                                     |
    | 00:29 | Copy the token, return to the GitHub integration settings, and paste the token.                                                                                            |
    | 00:36 | The token is validated when you save it to your profile settings.                                                                                                          |
    | 00:42 | Now, navigate to your projects.                                                                                                                                            |
    | 00:44 | You enable GitHub integration at the project level on the "Settings" tab.                                                                                                  |
    | 00:50 | Simply scroll to the bottom and paste the existing GitHub repository URL.                                                                                                  |
    | 00:56 | You'll find that on the "Code" tab in the repo.                                                                                                                            |
    | 01:01 | Click "Update" to make the connection.                                                                                                                                     |
    | 01:05 | Now, go to the "Assets" tab and open the notebook you want to publish.                                                                                                     |
    | 01:14 | Notice that this notebook has the credentials replaced with X's.                                                                                                           |
    | 01:19 | It's a best practice to remove or replace credentials before publishing to GitHub.                                                                                         |
    | 01:24 | So, this notebook is ready for publishing.                                                                                                                                 |
    | 01:27 | You can provide the target path along with a commit message.                                                                                                               |
    | 01:31 | You also have the option to publish content without hidden code, which means that any cells in the notebook that began with the hidden cell comment will not be published. |
    | 01:42 | When you're, ready click "Publish".                                                                                                                                        |
    | 01:45 | The message tells you that the notebook was published successfully and provides links to the notebook, the repository, and the commit.                                     |
    | 01:54 | Let's take a look at the commit.                                                                                                                                           |
    | 01:57 | So, there's the commit, and you can navigate to the repository to see the published notebook.                                                                              |
    | 02:04 | Lastly, you can publish as a gist.                                                                                                                                         |
    | 02:07 | Gists are another way to share your work on GitHub.                                                                                                                        |
    | 02:10 | Every gist is a git repository, so it can be forked and cloned.                                                                                                            |
    | 02:15 | There are two types of gists: public and secret.                                                                                                                           |
    | 02:19 | If you start out with a secret gist, you can convert it to a public gist later.                                                                                            |
    | 02:24 | And again, you have the option to remove hidden cells.                                                                                                                     |
    | 02:29 | Follow the link to see the published gist.                                                                                                                                 |
    | 02:32 | So that's the basics of Watson Studio's GitHub integration.                                                                                                                |
    | 02:37 | Find more videos in the Cloud Pak for Data as a Service documentation.                                                                                                     |
    
    <!-- </table "class="bx--data-table bx--data-table--zebra" style="border-collapse: collapse; border: none;" "> -->
    
<!-- </ul> -->

**Parent topic:**[Managing the lifecycle of notebooks and scripts](https://dataplatform.cloud.ibm.com/docs/content/wsj/analyze-data/manage-nb-lifecycle.html)

<!-- </article "role="article" "> -->