API Keys are under Settings > Security
Test mode secret keys have the prefix `cal_` and live mode secret keys have the prefix `cal_live_`.
Your API keys carry many privileges, so be sure to keep them secure! Do not share your secret API keys in publicly accessible areas such as GitHub, client-side code, and so forth.
Authentication to the API is performed via the Authorization header. For example, the request would go something like:
```
'Authorization': 'Bearer YOUR_API_KEY'
```
in your request header.
All API requests must be made over HTTPS. Calls made over plain HTTP will fail. API requests without authentication will also fail.
### 2. OAuth client credentials
You need to use OAuth credentials when:
1. Managing managed users [API reference](https://cal.com/docs/api-reference/v2/platform-managed-users/create-a-managed-user)
2. Creating OAuth client webhooks [API reference](https://cal.com/docs/api-reference/v2/platform-webhooks/create-a-webhook)
3. Refreshing tokens of a managed user [API reference](https://cal.com/docs/api-reference/v2/platform-managed-users/refresh-managed-user-tokens)
4. Teams related endpoints: Managing organization teams [API reference](https://cal.com/docs/api-reference/v2/orgs-teams/create-a-team), adding managed users as members to teams [API reference](https://cal.com/docs/api-reference/v2/orgs-teams-memberships/create-a-membership), creating team event types [API reference](https://cal.com/docs/api-reference/v2/orgs-event-types/create-an-event-type).
OAuth credentials can be accessed in the platform dashboard [https://app.cal.com/settings/platform](https://app.cal.com/settings/platform) after you have created an OAuth client. Each one has an ID and secret. You then need to pass them as request headers:
1. `x-cal-client-id` - ID of the OAuth client.
2. `x-cal-secret-key` - secret of the OAuth client.
### 3. Managed user access token
After you create a managed user you will receive its access and refresh tokens. The response also includes managed user's id, so we recommend you to add new properties to your users table calAccessToken, calRefreshToken and calManagedUserId to store this information.
You need to use access token when managing managed user's:
1. Schedules [API reference](https://cal.com/docs/api-reference/v2/schedules/create-a-schedule)
2. Event types [API reference](https://cal.com/docs/api-reference/v2/event-types/create-an-event-type)
3. Bookings - some endpoints like creating a booking is public, but some like getting all managed user's bookings require managed user's access token [API reference](https://cal.com/docs/api-reference/v2/bookings/get-all-bookings)
It is passed as an authorization bearer request header Authorization: Bearer \
A sample line where I used the component in the demo
A sample failure in create command
* When you edit an app following things aren't updated.
* README.mdx - It would still have the old description. Feel free to edit it manually.
### Publishing Your App to the Cal.com App Store
Once your app is working in your environment, you can publish it to Cal.com App Store by opening a PR [here](https://github.com/calcom/cal.com).
If you need any help feel free to join us in our [GitHub Discussions](https://github.com/calcom/cal.com/discussions).
# Assign people to a call from a CRM or database
Source: https://cal.com/docs/developing/guides/appstore-and-integration/how-to-show-assigned-people-from-a-crm
## Option 1: Based on CRM integration
If you are working with a CRM such as Salesforce, Hubspot, Close.com or similar, you can use our integrations to connect to your apps.
We're using the Assignee APIs from each service to understand which person is assigned to an email of a new lead.
By prefilling your booking link with ?email=[name@acme.com](mailto:name@acme.com) our integration will look up who has spoken to [name@acme.com](mailto:name@acme.com) before and skip all round-robin logic.
Here is an example URL: i.cal.com/sales/exploration?email=[name@acme.com](mailto:name@acme.com)
This works with Embeds as well, just add the parameter to your CalLink property.
## Option 2: Based on Emails
If you are using a different product that we don't integrate with, or you need something more custom you can also achieve this with our Organization plan.
We've built our Organization system in a way where every email can be turned into a scheduling link with your company subdomain:
[jane@acme.com](mailto:jane@acme.com) → acme.cal.com/jane (or schedule.acme.com/jane)
This means if you have a table
| User | AccountExecutive |
| :---------------------------------- | :------------------------------------ |
| [peer@cal.com](mailto:peer@cal.com) | [jane@acme.com](mailto:jane@acme.com) |
You could show [peer@cal.com](mailto:peer@cal.com) an embed inside your application simply by using the value from AccountExecutive to build the link:
[jane@acme.com](mailto:jane@acme.com) → acme.cal.com/jane either with a string replace function or a simple regex.
# Setting up OIDC with okta
Source: https://cal.com/docs/developing/guides/auth-and-provision/how-to-setup-oidc-with-okta
* Under "SCIM connector base URL" enter the "SCIM Base URL" from Cal.com
* Under "Unique identifier field for users" enter "email"
* Under "Supported provisioning actions" enable:
* "Import New Users and Profile Updates"
* "Push New Users"
* "Push Profile Updates"
* "Push Groups"
* Under "Authentication Mode" choose "HTTP Header"
* Under "Authentication" enter the "SCIM Bearer Token" from Cal.com
* When you hit save, it will make a test call to the "SCIM Base URL"
# SSO setup
Source: https://cal.com/docs/developing/guides/auth-and-provision/sso-setup
Cal.com supports both Security Assertion Markup Language (SAML) and OpenID Connect (OIDC), two of the industry's leading authentication protocols. We prioritize your ease of access and security by providing robust Single Sign-On (SSO) capabilities. Whether you're looking for the XML-based standard of SAML or the lightweight OIDC, our platform is equipped to integrate smoothly with your preferred identity provider, ensuring both convenience and security for your users.
### Setting up SAML login
`eventType: object` // Event Type that has been booked
`date: string` // Date of Event
`duration: number` // Duration of booked Event
`organizer: object` // Organizer details like name, timezone, email | | linkReady | Tells that the link is ready to be shown now. | None | | linkFailed | Fired if link fails to load. | `code: number` // Error Code
`msg: string` // Human Readable message
`data: object` // More details to debug the error | | \_\_iframeReady | It is fired when the embedded iframe is ready to communicate with parent snippet. This is mostly for internal use by Embed Snippet. | None | | \_\_windowLoadComplete | Tells that window load for iframe is complete. | None | | \_\_dimensionChanged | Tells that dimensions of the content inside the iframe changed. | `iframeWidth: number`
`iframeHeight: number` |
{t("no_data_yet")}
{/* Existing components */}
);
}
```
|
| Confusing UX (... but working) | 
|
| Core Features (Booking page, availability, timezone calculation) | 
|
| Core Bugs (Login, Booking page, Emails are not working) | 
|
### Developing
The development branch is `main`. This is the branch that all pull
requests should be made against. The changes on the `main`
branch are tagged into a release monthly.
To develop locally:
1. [Fork](https://help.github.com/articles/fork-a-repo/) this repository to your
own GitHub account and then
[clone](https://help.github.com/articles/cloning-a-repository/) it to your local device.
2. Create a new branch:
```bash
git checkout -b MY_BRANCH_NAME
```
3. Install yarn:
```bash
npm install -g yarn
```
4. Install the dependencies with:
```bash
yarn
```
5. Start developing and watch for code changes:
```bash
yarn dev
```
### Building
You can build the project with:
```bash
yarn build
```
Please be sure that you can make a full production build before pushing code.
### Testing
More info on how to add new tests coming soon.
### Running tests
This will run and test all flows in multiple Chromium windows to verify that no critical flow breaks:
```bash
yarn test-e2e
```
### Linting
To check the formatting of your code:
```bash
yarn lint
```
If you get errors, be sure to fix them before committing.
### Making a Pull Request
* Be sure to [check the "Allow edits from maintainers" option](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/allowing-changes-to-a-pull-request-branch-created-from-a-fork) while creating you PR.
* If your PR refers to or fixes an issue, be sure to add `refs #XXX` or `fixes #XXX` to the PR description. Replacing `XXX` with the respective issue number. See more about [Linking a pull request to an issue
](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue).
* Be sure to fill the PR Template accordingly.
### Guidelines for committing yarn lockfile
Do not commit your `yarn.lock` unless you've made changes to the `package.json`. If you've already committed `yarn.lock` unintentionally, follow these steps to undo:
If your last commit has the `yarn.lock` file alongside other files and you only wish to uncommit the `yarn.lock`:
```git
git checkout HEAD~1 yarn.lock
git commit -m "Revert yarn.lock changes"
```
If you've pushed the commit with the `yarn.lock`:
1. Correct the commit locally using the above method.
2. Carefully force push:
```git
git push origin 
Customizations can be done to the destination calendar settings atom via props. Below is a list of props that can be passed to the calendar settings atom
| Name | Required | Description |
| :----------- | :------- | :------------------------------------------------------------- |
| statusLoader | No | To pass in a custom component for the loading state |
| classNames | No | To pass in custom classnames from outside for styling the atom |
**2. Selected calendar settings atom**
The selected calendar settings atom lets you select which calendars you want to check for conflicts to prevent double bookings. Below code snippet can be used to render the selected calendar settings atom.
```js
import { SelectedCalendarsSettings } from "@calcom/atoms";
export default function SelectedCalendars( props : SelectedCalendarsProps ) {
return (
<>
Customizations can be done to the destination calendar settings atom via props. Below is a list of props that can be passed to the calendar settings atom
| Name | Required | Description |
| :--------- | :------- | :------------------------------------------------------------- |
| classNames | No | To pass in custom classnames from outside for styling the atom |
# Conferencing Apps
Source: https://cal.com/docs/platform/atoms/conferencing-apps
The Conferencing Apps Atom allows users to seamlessly install applications such as Zoom, Google Meet, and Microsoft Teams, enabling them to set these as default or optional locations for their events.
Below code snippet can be used to render Conferencing Apps Atom
```js
import { ConferencingAppsSettings } from "@calcom/atoms";
import { usePathname } from "next/navigation";
export default function ConferencingApps() {
const pathname = usePathname();
const callbackUri = `${window.location.origin}${pathname}`;
return (
<>
**2. Availability**
The availability tab allows users to manage their scheduling preferences effectively. Within this tab, users can edit their existing availability or set new availability options based on the preferences they have previously established.
For team event types, availability for a specific event can also be configured for the entire team based on a common schedule. Otherwise each host can be assigned their own specific availability based on their schedules.
**3. Assignment**
The assignment tab is only available for team event types. It lets you configure what kind of scheduling you want to enable for your team event, where you can choose from a collective, round robin or managed event. You can also choose who amongst your team can or cannot attend the event.
**4. Limits**
The limits tab lets you configure how often you can be booked. You can add a lot of configurations via this tab, such as a buffer time before or after the event and a minimum notice period.
Also if you want to select how many time a particular event can be booked, or how far in the future the event can be booked that is also possible. Or if you want to limit the event to a specific amount of time, that can also be done via the limits tab.
Below video shows a demonstration of the limits tab.
**5. Advanced**
The advanced tab lets you customize your event type with a lot more options. For example, you can set a custom name for the event type that will appear in your calendar, or add questions that will appear on your booking page. Another option would be to add an email verification for the person who is booking the event.
Below video shows a demonstration of the all the options you get in the advanced tab.
**6. Recurring**
The recurring tab lets you set up a recurring event. You can set up recurring events such as weekly, monthly, yearly, etc for a maximum of events you want it to repeat.
Once you connect your Stripe account, you can set a custom price along with the currency and payment option; which will determine when to charge your customers.
# Google calendar connect
Source: https://cal.com/docs/platform/atoms/google-calendar-connect
The Google calendar connect button is used to effortlessly syncs a user's google calendar. This allows users to create, view and edit events, with options available for type and time all from the platform.
Below code snippet can be used to render the Google calendar connect button
```js
import { Connect } from "@calcom/atoms";
export default function Connect() {
return (
<>
Upcoming bookings
{isLoadingUpcomingBookings &&Loading...
} {!isLoadingUpcomingBookings && !upcomingBookings &&No upcoming bookings found
} {!isLoading && upcomingBookings && (Boolean(upcomingBookings?.length)) && [...upcomingBookings].map((booking) => { return ({booking.title}
Loading...
} {!isLoadingBooking && !booking &&No booking found
} {!isLoading && !!booking && return (Title: {booking.title}
)
}
);
}
```
### 3. cancel booking - `useCancelBooking`
The useCancelBooking hook allows you to cancel a booking. This hook returns a mutation function that handles the cancellation process. To cancel a booking, you'll need to provide at least the booking's unique identifier ***(uid).*** While the uid is the only mandatory parameter, you can enhance the cancellation process by including optional parameters such as ***cancellationReason*** to specify why the booking is being canceled, and ***allRemainingBookings*** to specify whether to cancel all future recurring bookings.
Below code snippet shows how to use the useCancelBooking hook to cancel a booking for a user.
```js
import { useCancelBooking } from "@calcom/atoms";
export default function CancelBooking() {
const { mutate: cancelBooking } = useCancelBooking({
onSuccess: () => {
console.log("Booking canceled successfully!")
},
});
return (
<>
);
}
```
### 4. get all bookings of a user as an organization admin - `useOrganizationUserBookings`
The useBookings hooks returns bookings of user associated with the access token passed to the [\Upcoming bookings
{isLoadingUpcomingBookings &&Loading...
} {!isLoadingUpcomingBookings && !upcomingBookings &&No upcoming bookings found
} {!isLoading && upcomingBookings && (Boolean(upcomingBookings?.length)) && [...upcomingBookings].map((booking) => { return ({booking.title}
Upcoming bookings
{isLoadingUpcomingBookings &&Loading...
} {!isLoadingUpcomingBookings && !upcomingBookings &&No upcoming bookings found
} {!isLoading && upcomingBookings && (Boolean(upcomingBookings?.length)) && [...upcomingBookings].map((booking) => { return ({booking.title}
Loading...
} {!isLoadingConnectedCalendars && !userCalendars &&No connected calendars
} {!isLoadingConnectedCalendars && userCalendars && (Boolean(userCalendars?connectedCalendars?.length)) && userCalendars?connectedCalendars?.map((calendar) => { return (Calendar type: {calendar.integration.name}
Loading...
} {!isLoadingEvents && !eventTypes &&No event types found
} {!isLoadingEvents && eventTypes && (Boolean(eventTypes?.length)) && eventTypes?.map((event) => { return (Event: {event.slug}
Loading...
} {!isLoadingTeamEvents && !teamEventTypes &&No team events found
} {!isLoadingTeamEvents && teamEventTypes && (Boolean(teamEventTypes?.length)) && teamEventTypes?.map((event) => { return (Team event: {event.slug}
Loading...
} {!isLoadingEventType && !eventType &&No event type found
} {!isLoadingEventType && !!eventType && return (Title: {eventType.slug}
)
}
);
}
```
### 4. `useCreateEventType`
The useCreateEventType hook allows you to create a new event type. This hook returns a mutation function that handles the event type creation process. The mutation function accepts an object with the following properties: ***lengthInMinutes*** which is the length of the event in minutes, ***title*** which is the title of the event, ***slug*** which is the slug of the event, and ***description*** which is the description of the event.
Below code snippet shows how to use the useCreateEventType hook to set up an event type.
```js
import { useCreateEventType } from "@calcom/atoms";
export default function CreateEventType() {
const { mutate: createEventType, isPending } = useCreateEventType({
onSuccess: () => {
console.log("Event type created successfully!");
},
onError: () => {
console.log("Error creating event type");
},
});
return (
<>
);
}
```
### 5. `useCreateTeamEventType`
The useCreateTeamEventType hook allows you to create a new team event type. This hook returns a mutation function that handles the event type creation process. The mutation function accepts an object with the following properties: ***lengthInMinutes*** which is the length of the event in minutes, ***title*** which is the title of the event, ***slug*** which is the slug of the event, ***description*** which is the description of the event, schedulingType which can be either ***COLLECTIVE***, ***ROUND\_ROBIN*** or ***MANAGED***, ***hosts*** which is an array of hosts for the event and the ***teamId*** which is the id of the team.
Below code snippet shows how to use the useCreateTeamEventType hook to set up a team event type.
```js
import { useCreateTeamEventType } from "@calcom/atoms";
export default function CreateTeamEventType() {
const { mutate: createTeamEventType, isPending } = useCreateTeamEventType({
onSuccess: () => {
console.log("Event type created successfully!");
},
onError: () => {
console.log("Error creating event type");
},
});
return (
<>
);
}
```
# FAQ
Source: https://cal.com/docs/platform/faq
Answers to the most common questions about the Platform API and atoms.
### 1. What is an OAuth client?
* A platform OAuth client enables you communicate with our API and manage your users.
* It contains properties such as name, redirect uris and permissions required by your users.
### 2. What is a managed user?
* A managed user is just a representation of your user within our database containing basic information like e-mail.
* It can be used to manage the setup of integrations such as Google Calendar, your users bookings. availability, etc.
* You should store information about the managed users in your database and use the access token to make API calls on their behalf.
### 3. Are a cal.com user and a managed user related?
* No, a cal.com user and a managed user are not related in any way. We can consider them as two separate entities.
* A "managed user" is completely independent of user accounts on cal.com and you don't need to register users on the cal.com web application.
### 4. What is an access token?
* At the time of creating a managed user you'll be provided with an access token and a refresh token.
* Each managed user is linked with an access token which helps us in identifying which users scheduling we need to handle.
* The access token only lasts for 60 minutes after which you can query the refresh point with your refresh token which will give you a new access token.
* Inside of atoms we handle access token refreshing part ourselves, outside of that you may need to handle the refreshing part yourselves.
* Refresh tokens should never be exposed to the frontend, keep them secure and only use them on the backend.
### 5. What is an atom?
* An atom is a customizable UI component that handles scheduling on behalf of your user.
* Everything from the front-end to the API calls is being handled by the atom, all you need to do is import the atom and drop it in your code.
### 6. What are the minimum setup requirements for using atoms?
* You need to have a project that uses React version 18 and above.
* At the moment atoms are only supported in React, so there's no way to use them in vanilla js or any other popular framework.
### 7. Can recurring events be rescheduled?
* No, at the moment you are only allowed to cancel a recurring event.
### 8. Why toggle animation is not working in the AvailabilitySettings atom?
* For the AvailabilitySettings toggle animation to work set the reading direction on the `` element:
```html
...
```
### 9. What are the authentication methods for making calls to the v2 API?
Either of the two:
* Setting `Authorization: Bearer 
## Prefilling custom booking fields
We created an event type for managed user with custom text and select fields. Name and email fields are created by default. Here is the request:
That looks in booker like:
Let's say you want that when someone is trying to book one of your managed users that the
booking fields should be pre-filled with some data. We see that one of the booking fields has slug `coding-language` and the other
`help-with`. To pre-fill them you pass their slugs and values to the Booker atom's defaultFormValues prop:
```js
## Making pre-filled fields read-only
`disableOnPrefill` booking field property controls whether or not to make a booking field read only if we pass its value in the defaultFormValues prop. Here is an example request
where we create an event type with one booking field with "disableOnPrefill": true and the other with "disableOnPrefill": false:
If we pass their values to the Booker atom:
```js
# Booking redirects
Source: https://cal.com/docs/platform/guides/booking-redirects
Find out how to manage the booking flow.
When creating an OAuth client you can specify:
1. booking URL to manage where people land after booking after one of your users.
2. reschedule URL to your page for rescheduling a booking.
3. cancel URL to your page for cancelling a booking.
This guide will explain each of the URLs and how to create page for each of them using atoms and our hooks.
## Booking URL
After a person books one of your users, that person should see the successful booking.
Page in the booking URL will take URL parameter provided by us and then hook to fetch the booking and then display it. Here is an example:
1. Pass `my-app.com/bookings` as the redirectURI.
2. In your app, create `my-app.com/bookings/[bookingUid]` page where bookingUid will become path parameter.
3. When a booking occurs, booker will be re-directed to the redirectURI with booking UID as the bookingUid parameter aka my-app.com/bookings/\[bookingUid].
4. In the my-app.com/bookings/\[bookingUid] route create a page that imports `useBooking` hook, then extract bookingUid from URL parameter, and uses the hook to display booking information. Because
`useBooking` hook can return individual booking or an array of recurring bookings, you need to handle single booking and array of bookings cases separately:
```js
import { useBooking } from "@calcom/atoms";
export default function Bookings(props: { calUsername: string; calEmail: string }) {
const router = useRouter();
const { isLoading, data: booking, refetch } = useBooking((router.query.bookingUid as string) ?? "");
return (
<>
{!Array.isArray(booking) ? (
{booking.title}
) : ( booking.map((recurrence) =>{recurrence.title}
) )} ) }; ``` An example implementation can be found [here](https://github.com/calcom/cal.com/blob/main/packages/platform/examples/base/src/pages/%5BbookingUid%5D.tsx). ## Reschedule URL 1. Pass `my-app.com/bookings/reschedule` as the redirectURI. 2. When “Reschedule” is clicked, user will be re-directed to the redirectURI with rescheduled and eventTypeSlug query parameters `my-app.com/reschedule?rescheduleUid=buiaE8jHmNAxLrqitahCeL&eventTypeSlug=thirty-minutes` 3. In the my-app.com/reschedule route create a page that extracts `rescheduleUid` and `eventTypeSlug` from the query parameters and passes the to the `Booker` atom: ```js const rescheduleUid = (router.query.rescheduleUid as string) ?? ""; const eventTypeSlugQueryParam = (router.query.eventTypeSlug as string) ?? "";
We can disable them using `disableToasts` prop:
```js
Teams event
) } ```
Get started
This will redirect you to the Cal.com signup page which looks like this
Loading...
} {!isLoadingUser && !userData &&No user found
} {!isLoadingUser && !!userData && return (Username: {userData.username}
)
}
);
}
```
### 2. `useTeams`
The useTeams returns all teams info. This hook is useful when you need to display or manage a user's entire collection of teams.
Below code snippet shows how to use the useTeams hook to fetch team details.
```js
import { useTeams } from "@calcom/atoms";
export default function UserTeams() {
const { data: teams, isLoading: isLoadingTeams } = useTeams();
return (
<>
{isLoadingTeams && Loading...
} {!isLoadingTeams && !teams &&No teams found
} {!isLoadingTeams && teams && (Boolean(teams?.length)) && teams?.map((team) => { return (Team name: {team.name}
# GCP
Source: https://cal.com/docs/self-hosting/deployments/gcp
Deploying Cal.com on Google Cloud Platform (GCP)
In this guide, we will go over the steps to deploy cal.com on Google Cloud Platform (GCP). We will cover how to create a virtual machine, configure it, install Docker, and finally deploy the cal.com application.
## One Click Deployment
## Manual Deployment
# Render
Source: https://cal.com/docs/self-hosting/deployments/render
You can deploy Cal.com on Render using the button below.
## One Click Deployment
# Vercel
Source: https://cal.com/docs/self-hosting/deployments/vercel
## Requirements
Currently Vercel Pro Plan is required to be able to Deploy this application with Vercel, due to limitations on the number of serverless functions on the free plan.
You need a PostgresDB database hosted somewhere. [Supabase](https://supabase.com/) offer a great free option while [Heroku](https://www.heroku.com/) offers a low-cost option.
## One Click Deployment
## Step 2: Configure Environment Variables
Set the following environment variables in your `.env` file:
```bash
NEXT_PUBLIC_WEBAPP_URL=http://app.cal.local:3000
NEXT_PUBLIC_WEBSITE_URL=http://app.cal.local:3000
NEXTAUTH_URL=http://app.cal.local:3000
ORGANIZATIONS_ENABLED=1
```
## Step 3: Configure Local DNS
Add the following entry to your hosts file to enable local access:
```bash
127.0.0.1 app.cal.local
```
**Host file locations:**
* **Linux/Mac**: `/etc/hosts`
* **Windows**: `C:\Windows\System32\drivers\etc\hosts`
## Step 4: Start/Restart Development Server
After making the configuration changes, start/restart your development server:
```bash
yarn dev
```
## Step 5: Create an Organization
1. Login using `pro@example.com` (or any user account)
2. Visit `http://app.cal.local:3000/settings/organizations/new`
3. Follow the onboarding steps:
* Choose a slug for the organization(say `myorg`)
* Ignore pricing information (not required for self-hosting)
* Complete the first step (remaining steps can be skipped for now)
or
### HTML Code:
```html
```
or
```html
```
## How to apply
Please note that we have a limited number of openings for OSS sponsorships each month. If you're interested in applying for a sponsorship for your open source software project, please follow these steps:
* Ensure that you meet all the sponsorship criteria mentioned above.
* Send an email to [peer@cal.com](mailto:peer@cal.com) and explain what you are working on and confirm that you meet all the sponsorship criteria (watch out, Peer may invest a small angel check in your COSS company 👀)
* Explaining why Cal.com's free tier or open core is insufficient for your project
* Include your Cal.com team slug and provide a link to your open source repository in the email.
6. Click on Configure SSO with OIDC, and then enter the Client Secret, Client ID and Well known URL from the Step 3, and click save.
7. That's it. Now when you try to login with SSO, your OIDC provider will handle the auth.
# Upgrading
Source: https://cal.com/docs/self-hosting/upgrading
Pull the current version:
```
git pull
```
Check if dependencies got added/updated/removed
```
yarn
```
Apply database migrations by running **one of** the following commands:
In a development environment, run:
```
yarn workspace @calcom/prisma db-migrate
```
(this can clear your development database in some cases)
In a production environment, run:
```
yarn workspace @calcom/prisma db-deploy
```
Check for `.env` variables changes
```
yarn predev
```
Start the server. In a development environment, just do:
```
yarn dev
```
For a production build, run for example:
```
yarn build
yarn start
```
Enjoy the new version.